cloudscraper — Un modulo Python per bypassare la pagina anti-bot di Cloudflare. | Kitploit

Qualsiasi script che utilizza cloudscraper attenderà circa 5 secondi alla prima visita di qualsiasi sito con Cloudflare anti-bot abilitato, anche se non si verificherà alcun ritardo dopo la prima richiesta.

# Installazione

Basta eseguire `pip install cloudscraper`. Il pacchetto PyPI è disponibile su https://pypi.org/project/cloudscraper/```bash
pip install cloudscraper

L'API rimane compatibile, quindi devi solo modificare le istruzioni di importazione nel tuo codice. Tutte le chiamate di funzione e i parametri funzionano allo stesso modo.

### Struttura del Codebase

Il codebase è stato ottimizzato per migliorare la manutenibilità e ridurre la confusione:

- **Modulo Unico**: Tutto il codice ora si trova nel modulo `cloudscraper`
- **Ridondanza Rimossa**: Le directory ridondanti sono state rimosse
- **Test Aggiornati**: Tutti i file di test sono stati aggiornati per utilizzare il modulo `cloudscraper`

Questo rende il codebase più pulito e facile da mantenere, garantendo al contempo la compatibilità con il codice esistente che utilizza l'API originale.

## Caratteristiche Principali in cloudscraper

| Caratteristica | Descrizione | Stato |
|---------|-------------|--------|
| **🆕 Compatibilità Esecutivi** | Correzione completa per la conversione con PyInstaller, cx_Freeze, auto-py-to-exe | ✅ **RISOLTO** |
| **🆕 Sfide JavaScript VM v3** | Supporto per le più recenti sfide basate su JavaScript VM di Cloudflare | ✅ **NUOVO** |
| **🆕 Supporto Turnstile** | Supporto per il nuovo Turnstile di Cloudflare, sostitutivo dei CAPTCHA | ✅ **NUOVO** |
| **Supporto Sfide Moderne** | Supporto potenziato per le sfide Cloudflare v1, v2, v3 e Turnstile | ✅ Completo |
| **Rotazione Proxy** | Rotazione intelligente dei proxy integrata con multiple strategie | ✅ Potenziato |
| **Modalità Stealth** | Simulazione di comportamento umano per evitare il rilevamento | ✅ Potenziato |
| **Emulazione Browser** | Fingerprinting avanzato del browser per Chrome e Firefox | ✅ Stabile |
| **Gestione JavaScript** | Migliore interprete JavaScript (js2py come predefinito) per la risoluzione delle sfide | ✅ Potenziato |
| **Risolutori Captcha** | Supporto per molteplici servizi di risoluzione CAPTCHA | ✅ Stabile |

# Dipendenze

- **Python 3.8+** (Supporto rimosso per Python 3.6 e 3.7)
- **[Requests](https://github.com/psf/requests)** >= 2.31.0
- **[requests_toolbelt](https://pypi.org/project/requests-toolbelt/)** >= 1.0.0
- **[pyparsing](https://pypi.org/project/pyparsing/)** >= 3.1.0
- **[pyOpenSSL](https://pypi.org/project/pyOpenSSL/)** >= 24.0.0
- **[pycryptodome](https://pypi.org/project/pycryptodome/)** >= 3.20.0
- **[websocket-client](https://pypi.org/project/websocket-client/)** >= 1.7.0
- **[js2py](https://pypi.org/project/Js2Py/)** >= 0.74
- **[brotli](https://pypi.org/project/Brotli/)** >= 1.1.0
- **[certifi](https://pypi.org/project/certifi/)** >= 2024.2.2

`python setup.py install` installerà automaticamente le dipendenze Python. Gli interpreti e/o motori JavaScript che decidi di utilizzare sono le uniche cose che devi installare tu stesso, escluso js2py che fa parte dei requisiti come predefinito.

# Interpreti e Motori JavaScript

Supportiamo i seguenti interpreti/motori JavaScript.

- **[ChakraCore](https://github.com/microsoft/ChakraCore):** Le librerie binarie possono essere trovate anche [qui](https://www.github.com/VeNoMouS/cloudscraper/tree/ChakraCore/).
- **[js2py](https://github.com/PiotrDabkowski/Js2Py):** >=0.74 **(Predefinito per la versione potenziata)**
- **native**: Risolutore Python nativo autocostruito
- **[Node.js](https://nodejs.org/)**
- **[V8](https://github.com/sony/v8eval/):** Utilizziamo il modulo Python [v8eval](https://v8.dev)() di Sony.

# Utilizzo

Il modo più semplice per utilizzare cloudscraper è chiamare `create_scraper()`.```python
import cloudscraper

scraper = cloudscraper.create_scraper()  # returns a CloudScraper instance
# Or: scraper = cloudscraper.CloudScraper()  # CloudScraper inherits from requests.Session
print(scraper.get("http://somesite.com").text)  # => "<!DOCTYPE html><html><head>..."

Le tue applicazioni cloudscraper ora funzioneranno perfettamente quando convertite in eseguibili! 🎉

## 🆕 Supporto per le Challenge JavaScript VM di Cloudflare v3

### Cosa sono le Challenge v3?

Le challenge v3 di Cloudflare rappresentano l'evoluzione più recente nella tecnologia di protezione dai bot. A differenza delle tradizionali challenge v1 e v2, le challenge v3:

- **Eseguono in una Virtual Machine JavaScript**: Le challenge vengono eseguite in un ambiente JavaScript sandbox
- **Usano rilevamento avanzato**: Algoritmi più sofisticati per rilevare il comportamento automatizzato
- **Generano codice dinamico**: Il codice delle challenge viene creato dinamicamente ed è più difficile da sottoporre a reverse engineering
- **Offrono protezione moderna**: La tecnologia anti-bot più attuale di Cloudflare

### Utilizzo base di v3```python
import cloudscraper

# v3 support is enabled by default
scraper = cloudscraper.create_scraper()
response = scraper.get("https://example.com")
print(response.text)

### v3 con diversi interpreti JavaScript

Tutti gli interpreti JavaScript funzionano con le sfide v3:```python
# Test different interpreters for v3 challenges
interpreters = ['js2py', 'nodejs', 'native']

for interpreter in interpreters:
    try:
        scraper = cloudscraper.create_scraper(interpreter=interpreter)
        response = scraper.get("https://example.com")
        print(f"✅ {interpreter}: Success ({response.status_code})")
    except Exception as e:
        print(f"❌ {interpreter}: Failed - {str(e)}")

### Considerazioni sulle prestazioni per v3

Le sfide v3 sono più complesse e potrebbero richiedere più tempo:```python
# Recommended settings for v3 challenges
scraper = cloudscraper.create_scraper(
    delay=5,              # Longer delay for complex challenges
    interpreter='js2py',  # Most compatible interpreter
    enable_stealth=True   # Additional stealth for v3 detection
)

### Esempio 2: Configurazione Avanzata per la Massima Compatibilità```python
import cloudscraper

# Advanced configuration for challenging websites
scraper = cloudscraper.create_scraper(
    # Challenge handling
    interpreter='js2py',        # Best compatibility for v3 challenges
    delay=5,                    # Extra time for complex challenges

    # Stealth mode
    enable_stealth=True,
    stealth_options={
        'min_delay': 2.0,
        'max_delay': 6.0,
        'human_like_delays': True,
        'randomize_headers': True,
        'browser_quirks': True
    },

    # Browser emulation
    browser='chrome',

    # Debug mode
    debug=True
)

response = scraper.get("https://example.com")

### Esempio 4: Rotazione del proxy con supporto v3```python
import cloudscraper

proxies = [
    'http://user:[email protected]:8080',
    'http://user:[email protected]:8080',
    'http://user:[email protected]:8080'
]

scraper = cloudscraper.create_scraper(
    # Proxy rotation
    rotating_proxies=proxies,
    proxy_options={
        'rotation_strategy': 'smart',
        'ban_time': 300
    },

    # v3 challenge support
    interpreter='js2py',
    delay=5,

    # Stealth mode
    enable_stealth=True
)

# Each request may use a different proxy
for i in range(5):
    response = scraper.get("https://example.com")
    print(f"Request {i+1}: {response.status_code}")

scraper = cloudscraper.create_scraper(
    interpreter='js2py',
    delay=5,
    debug=True,
    enable_stealth=True
)

test_urls = [
    "https://example1.com",  # Might have v1 challenges
    "https://example2.com",  # Might have v2 challenges
    "https://example3.com",  # Might have v3 challenges
    "https://example4.com",  # Might have Turnstile
]

for url in test_urls:
    try:
        response = scraper.get(url)
        print(f"✅ {url}: Success ({response.status_code})")
    except Exception as e:
        print(f"❌ {url}: Failed - {str(e)}")

## 🧪 Test e Verifica

### Suite di Test Completa

cloudscraper include script di test completi per verificare che tutte le funzionalità funzionino correttamente:```bash
# Test all features
python test_all_features.py --debug

# Test specifically v3 challenges
python test_v3_challenges.py --debug

# Test with specific interpreter
python test_v3_challenges.py --interpreter nodejs

Funzionalità	Copertura Test	Tasso di Successo
Richieste di Base	✅ Completa	100%
Gestione User Agent	✅ Completa	100%
Sfide Cloudflare v1	✅ Completa	100%
Sfide Cloudflare v2	✅ Completa	100%
Sfide Cloudflare v3	✅ NUOVO	100%
Modalità Stealth	✅ Completa	100%
Interpreti JavaScript	✅ Tutti Supportati	100%
Rotazione Proxy	✅ Completa	N/D*
Supporto Turnstile	✅ Completa	N/D*

### Risoluzione dei problemi

Se incontri problemi:

1. **Attiva la modalità di debug** per vedere informazioni dettagliate
2. **Prova diversi interpreti** (js2py, nodejs, native)
3. **Aumenta il ritardo** per sfide complesse
4. **Attiva la modalità stealth** per una protezione aggiuntiva
5. **Controlla la configurazione del proxy** se usi proxy```python
# Troubleshooting configuration
scraper = cloudscraper.create_scraper(
    debug=True,           # See what's happening
    interpreter='js2py',  # Most compatible
    delay=10,            # Extra time
    enable_stealth=True  # Additional protection
)

### Disable Cloudflare V2
#### Descrizione

Se non vuoi nemmeno provare a risolvere Cloudflare v2..

#### Parametri


|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|disableCloudflareV2|(boolean)|False|

#### Esempio```python
scraper = cloudscraper.create_scraper(disableCloudflareV2=True)

### Disabilita Turnstile
#### Descrizione

Se non vuoi nemmeno tentare di risolvere Cloudflare Turnstile..

#### Parametri

|Parametro|Valore|Default|
|-------------|:-------------:|:-----:|
|disableTurnstile|(boolean)|False|

#### Esempio```python
scraper = cloudscraper.create_scraper(disableTurnstile=True)

### Modalità Stealth
#### Descrizione

Abilita tecniche stealth per imitare meglio il comportamento umano ed evitare il rilevamento.

#### Parametri

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|enable_stealth|(boolean)|True|
|stealth_options|(dict)|{}|

#### Parametri di `stealth_options`

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|min_delay|(float) ritardo minimo tra le richieste|1.0|
|max_delay|(float) ritardo massimo tra le richieste|5.0|
|human_like_delays|(boolean) aggiunge ritardi casuali tra le richieste|True|
|randomize_headers|(boolean) randomizza gli header per evitare il fingerprinting|True|
|browser_quirks|(boolean) applica peculiarità specifiche del browser|True|

#### Esempio```python
scraper = cloudscraper.create_scraper(
    enable_stealth=True,
    stealth_options={
        'min_delay': 2.0,
        'max_delay': 6.0,
        'human_like_delays': True,
        'randomize_headers': True,
        'browser_quirks': True
    }
)

### Filtraggio Browser / User-Agent

#### Descrizione

Controlla come e quale User-Agent viene selezionato "casualmente".

#### Parametri

Può essere passato come argomento a `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|browser|(stringa) `chrome` o `firefox`|None|

Oppure

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|browser|(dict)||

##### Parametri di `browser` *_dict_*
|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|browser|(stringa) `chrome` o `firefox`|None|
|mobile|(booleano)|True|
|desktop|(booleano)|True|
|platform|(stringa) `'linux', 'windows', 'darwin', 'android', 'ios'`|None|
|custom|(stringa)|None|
#### Esempio```python
scraper = cloudscraper.create_scraper(browser='chrome')

### Debug

#### Descrizione

Stampa le informazioni su intestazione e contenuto della richiesta per il debug.

#### Parametri

Può essere impostato come attributo tramite il tuo oggetto `cloudscraper` o passato come argomento a `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|debug|(boolean)|False|

#### Esempio```python
scraper = cloudscraper.create_scraper(debug=True)

### Sessione esistente

#### Descrizione:

Se hai già una sessione Requests esistente, puoi passarla alla funzione `create_scraper()` per continuare a usare quella sessione.

#### Parametri

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|sess|(requests.session)|None|

#### Esempio```python
session = requests.session()
scraper = cloudscraper.create_scraper(sess=session)

#### Nota

La versione avanzata usa `js2py` come interprete predefinito perché offre una migliore compatibilità con le moderne sfide Cloudflare. Se riscontri problemi, puoi provare altri interpreti.

------

### Risolutori di Captcha di Terze Parti

#### Descrizione

`cloudscraper` attualmente supporta i seguenti risolutori Captcha di terze parti, nel caso tu ne abbia bisogno.

- **[2captcha](https://www.2captcha.com/)**
- **[anticaptcha](https://www.anti-captcha.com/)**
- **[CapSolver](https://capsolver.com/)**
- **[CapMonster Cloud](https://capmonster.cloud/)**
- **[deathbycaptcha](https://www.deathbycaptcha.com/)**
- **[9kw](https://www.9kw.eu/)**
- **__return_response__**

#### Nota

Sto lavorando per aggiungere ulteriori risolutori di terze parti; se desideri che venga aggiunto un servizio attualmente non supportato, apri un ticket di supporto su GitHub.

##### Parametri Richiesti

Possono essere impostati come attributo tramite il tuo oggetto `cloudscraper` oppure passati come argomento a `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Parametro|Valore|Predefinito|
|-------------|:-------------:|:-----:|
|captcha|(dict)|None|

#### Supporto Turnstile

Cloudflare Turnstile è una nuova alternativa ai CAPTCHA che sostituisce i CAPTCHA tradizionali con un sistema di verifica più intuitivo. `cloudscraper` ora supporta la risoluzione delle sfide Turnstile utilizzando gli stessi provider di captcha che già conosci.

##### Esempio```python
# Using 2captcha to solve Turnstile challenges
scraper = cloudscraper.create_scraper(
  captcha={
    'provider': '2captcha',
    'api_key': 'your_2captcha_api_key'
  }
)

# The Turnstile challenge will be automatically detected and solved
response = scraper.get('https://example.com')

#### anticaptcha

##### Parametri `captcha` richiesti

|Parametro|Valore|Obbligatorio|Predefinito|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `anticaptcha`|sì||
|api_key|(string)|sì||
|no_proxy|(boolean)|no|False|

##### Nota

se i proxy sono impostati, puoi disabilitare l'invio dei proxy ad anticaptcha impostando `no_proxy` a `True`

##### Esempio```python
scraper = cloudscraper.create_scraper(
  captcha={
    'provider': 'anticaptcha',
    'api_key': 'your_anticaptcha_api_key'
  }
)

#### CapMonster Cloud

##### Parametri `captcha` richiesti

|Parametro|Valore|Richiesto|Predefinito|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `capmonster`| sì||
|clientKey|(string)| sì||
|no_proxy|(boolean)|no|False|

##### Nota

se i proxy sono impostati, puoi disabilitare l'invio dei proxy a CapMonster impostando `no_proxy` a `True`

##### Esempio```python
scraper = cloudscraper.create_scraper(
  captcha={
    'provider': 'capmonster',
    'clientKey': 'your_capmonster_clientKey'
  }
)

#### 9kw

##### Parametri `captcha` richiesti

|Parametro|Valore|Richiesto|Predefinito|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `9kw`|sì||
|api_key|(string)|sì||
|maxtimeout|(int)|no|180|

##### Esempio```python
scraper = cloudscraper.create_scraper(
  captcha={
    'provider': '9kw',
    'api_key': 'your_9kw_api_key',
    'maxtimeout': 300
  }
)

## Integration

È facile integrare `cloudscraper` con altre applicazioni e strumenti. Cloudflare usa due cookie come token: uno per verificare che tu abbia superato la loro pagina di verifica e uno per tracciare la tua sessione. Per bypassare la pagina di verifica, basta includere entrambi questi cookie (con il relativo user-agent) in tutte le richieste HTTP che effettui.

Per recuperare solo i cookie (come dizionario), usa `cloudscraper.get_tokens()`. Per recuperarli come header HTTP `Cookie` completo, usa `cloudscraper.get_cookie_string()`.

`get_tokens` e `get_cookie_string` accettano entrambi i normali argomenti di Requests (come `get_tokens(url, proxies={"http": "socks5://localhost:9050"})`).

Si prega di leggere la [documentazione di Requests sugli argomenti delle richieste](http://docs.python-requests.org/en/master/api/#requests.Session.request) per maggiori informazioni.

------

### Gestione dello User-Agent

Le due funzioni di integrazione restituiscono una tupla `(cookie, user_agent_string)`.

**Devi usare la stessa stringa user-agent sia per ottenere i token sia per effettuare richieste con quei token, altrimenti Cloudflare ti segnalerà come bot.**

Ciò significa che devi passare la `user_agent_string` restituita a qualsiasi script, strumento o servizio a cui passi i token (ad esempio curl, o uno strumento di scraping specializzato), e questo deve usare quell'user-agent passato quando effettua richieste HTTP.

------

### Esempi di integrazione

Ricorda, devi sempre usare lo stesso user-agent quando recuperi o usi questi cookie. Queste funzioni restituiscono tutte una tupla `(cookie_dict, user_agent_string)`.

------

#### Recupero di un dict di cookie attraverso un proxy

`get_tokens` è una funzione di comodo per restituire un dict Python contenente i cookie di sessione di Cloudflare. Per dimostrazione, configureremo questa richiesta per usare un proxy. (Nota: se richiedi i token di clearance di Cloudflare tramite un proxy, devi sempre usare lo stesso proxy quando quei token vengono passati al server. Cloudflare richiede che l'IP che risolve la sfida e l'IP del visitatore rimangano gli stessi.)

Se non desideri usare un proxy, basta non passare l'argomento `proxies`. Queste funzioni di comodo supportano tutti i normali argomenti di Requests, come `params`, `data` e `headers`.```python
import cloudscraper

# Using a single proxy
proxies = {"http": "http://localhost:8080", "https": "http://localhost:8080"}
tokens, user_agent = cloudscraper.get_tokens("http://somesite.com", proxies=proxies)
print(tokens)
# => {
    'cf_clearance': 'c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600',
    '__cfduid': 'dd8ec03dfdbcb8c2ea63e920f1335c1001426733158',
    'cf_chl_2': 'some_value',
    'cf_chl_prog': 'some_value'
}

# Using proxy rotation
rotating_proxies = [
    'http://user:[email protected]:8080',
    'http://user:[email protected]:8080',
    'http://user:[email protected]:8080'
]

tokens, user_agent = cloudscraper.get_tokens(
    "http://somesite.com",
    rotating_proxies=rotating_proxies,
    proxy_options={
        'rotation_strategy': 'smart',
        'ban_time': 300
    },
    enable_stealth=True,
    stealth_options={
        'min_delay': 2.0,
        'max_delay': 6.0
    }
)

#### esempio di curl

Ecco un esempio di integrazione di cloudscraper con curl. Come puoi vedere, tutto ciò che devi fare è passare i cookie e lo user-agent a curl.```python
import subprocess
import cloudscraper

# With get_tokens() cookie dict:

# tokens, user_agent = cloudscraper.get_tokens("http://somesite.com")
# cookie_arg = 'cf_clearance={}; __cfduid={}'.format(tokens['cf_clearance'], tokens['__cfduid'])

# With get_cookie_string() cookie header; recommended for curl and similar external applications:

cookie_arg, user_agent = cloudscraper.get_cookie_string('http://somesite.com')

# With a custom user-agent string you can optionally provide:

# ua = "Scraping Bot"
# cookie_arg, user_agent = cloudscraper.get_cookie_string("http://somesite.com", user_agent=ua)

result = subprocess.check_output(
    [
        'curl',
        '--cookie',
        cookie_arg,
        '-A',
        user_agent,
        'http://somesite.com'
    ]
)

### Cryptography

#### Description

Controlla la comunicazione tra client e server

#### Parameters

Può essere passato come argomento a `create_scraper()`.

|Parameter|Value|Default|
|-------------|:-------------:|:-----:|
|cipherSuite|(string)|None|
|ecdhCurve|(string)|prime256v1|
|server_hostname|(string)|None|

#### Example```python
# Some servers require the use of a more complex ecdh curve than the default "prime256v1"
# It may can solve handshake failure
scraper = cloudscraper.create_scraper(ecdhCurve='secp384r1')

# Funzionalità Avanzate

Questa versione avanzata di cloudscraper offre migliori capacità per bypassare i moderni meccanismi di protezione di Cloudflare:

1. **Supporto Cloudflare v2 Challenge** - Migliore gestione delle sfide moderne
2. **Rotazione Proxy** - Rotazione intelligente con più strategie
3. **Modalità Stealth** - Simulazione di comportamento umano
4. **Gestione JavaScript Migliorata** - Migliore interprete JS (js2py come predefinito)
5. **Gestione Cookie Avanzata** - Supporto per i nuovi tipi di cookie Cloudflare

## Aggiornamenti Recenti

- **Pulizia del Codebase**: Rimosso codice ridondante e consolidato in un unico modulo
- **Aggiornamenti della Suite di Test**: Tutti i test ora usano il modulo cloudscraper
- **Documentazione**: README migliorato con esempi più chiari e istruzioni d'uso

## Esempio con Tutte le Funzionalità Avanzate```python
import cloudscraper

# Create a scraper with all enhanced features
scraper = cloudscraper.create_scraper(
    # Use js2py interpreter for better compatibility
    interpreter='js2py',

    # Enable proxy rotation
    rotating_proxies=[
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080',
        'http://user:[email protected]:8080'
    ],
    proxy_options={
        'rotation_strategy': 'smart',
        'ban_time': 300
    },

    # Enable stealth mode
    enable_stealth=True,
    stealth_options={
        'min_delay': 2.0,
        'max_delay': 6.0,
        'human_like_delays': True,
        'randomize_headers': True,
        'browser_quirks': True
    },

    # Set browser fingerprint
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'mobile': False
    },

    # Enable debugging if needed
    debug=False
)

# Make a request to a Cloudflare-protected site
response = scraper.get('https://example.com')
print(response.text)

### Esecuzione della Suite di Test

La libreria include diversi script di test:```bash
# Run the comprehensive test suite
python test_cloudscraper_comprehensive.py https://example-cloudflare-site.com

# Test with a specific Cloudflare-protected site
python test_cloudflare_site.py https://example-cloudflare-site.com --browser firefox --stealth

Parametro	Valore	Predefinito
rotation_strategy	(stringa) `sequential`, `random` o `smart`	`sequential`
ban_time	(int) secondi per bannare un proxy dopo un errore	300

Parametro	Valore	Obbligatorio	Predefinito
provider	(stringa) `2captcha`	sì
api_key	(stringa)	sì
no_proxy	(booleano)	no	False

Parametro	Valore	Obbligatorio
provider	(string) `deathbycaptcha`	sì
username	(string)	sì
password	(string)	sì

Parametro	Valore	Predefinito
rotating_proxies	(lista o dict)	None
proxy_options	(dict)	{}

Più Popolari

cloudscraper

cloudscraper - Edizione Potenziata

Ultima versione: v3.0.0 🚀 - Aggiornamento principale

🆕 Nuove funzionalità principali in v3.0.0

🔧 Modifiche non retrocompatibili

✅ Funzionalità precedenti (ancora disponibili)

🔧 Miglioramenti

📊 Risultati dei test

Migrazione da cloudscraper

Enhanced import

✅ Compatibilità degli Eseguibili (v2.7.0)

Problema Risolto!

Qual era il problema?

La Soluzione

Come Usare

Test

Configurazione avanzata v3```python

Optimized configuration for v3 challenges

v3 Challenge Detection

Debug output will show:

"Detected a Cloudflare v3 JavaScript VM challenge."

🚀 Esempi completi

Esempio 1: Utilizzo di base con tutti i tipi di sfida```python

Create a scraper that handles all challenge types automatically

This will automatically handle v1, v2, v3, and Turnstile challenges

Esempio 3: Gestire Turnstile con risolutore CAPTCHA```python

Configure with 2captcha for Turnstile challenges

Turnstile challenges will be automatically detected and solved

Esempio 5: Testare Diversi Tipi di Challenge```python

Riepilogo dei Risultati dei Test

Test Manuale

Enable debug mode to see what's happening

Debug output will show:

- Challenge type detected (v1, v2, v3, Turnstile)

- JavaScript interpreter used

- Challenge solving process

- Final response status

Options

Disable Cloudflare V1

Description

Parameters

Example```python

Disabilita Cloudflare V3

Descrizione

Parametri

Esempio```python

Rotazione Proxy

Descrizione

Parametri

Parametri di proxy_options

Esempio```python

Brotli

Descrizione

Parametri

Esempio```python

will give you only mobile chrome User-Agents on Android

will give you only desktop firefox User-Agents on Windows

Custom will also try find the user-agent string in the browsers.json,

If a match is found, it will use the headers and cipherSuite from that "browser",

Otherwise a generic set of headers and cipherSuite will be used.

Ritardi

Descrizione

Parametri

Esempio```python

Nota

Motori e Interpreti JavaScript

Descrizione

Parametri

Esempio```python

2captcha

Parametri captcha richiesti

Nota

Esempio```python

CapSolver

Parametri captcha obbligatori

Esempio```python

deathbycaptcha

Parametri captcha obbligatori

Esempio```python

Parametri di `proxy_options`

Parametri `captcha` richiesti

Parametri `captcha` obbligatori

Parametri `captcha` obbligatori

Parametri `captcha` richiesti