cloudscraper - Edizione Potenziata

Potenziato da Zied Boughdir

Ultima versione: v3.0.0 🚀 - Aggiornamento principale

🆕 Nuove funzionalità principali in v3.0.0

🛡️ Recupero automatico dagli errori 403 - Aggiornamento intelligente della sessione quando si verificano errori 403 dopo un uso prolungato
📊 Monitoraggio dello stato della sessione - Gestione proattiva della sessione con intervalli di aggiornamento configurabili
🔄 Aggiornamento intelligente della sessione - Pulizia automatica dei cookie e rotazione del fingerprint
🎯 Modalità stealth potenziata - Miglioramento dell'anti-rilevamento con simulazione di comportamento umano
🔧 Supporto Python moderno - Python 3.8+ con le ultime versioni delle dipendenze
📦 Packaging moderno - Usa pyproject.toml e strumenti di build moderni
🧪 Test completi - Nuova suite di test con pytest e integrazione CI/CD
🚀 Miglioramenti delle prestazioni - Codice ottimizzato con una migliore gestione degli errori

🔧 Modifiche non retrocompatibili

Versione minima di Python: ora richiede Python 3.8+
Dipendenze aggiornate: tutte le dipendenze aggiornate alle ultime versioni stabili
Codice legacy rimosso: ripulito il codice di compatibilità con Python 2

✅ Funzionalità precedenti (ancora disponibili)

Correzione compatibilità eseguibili - Soluzione completa per la conversione con PyInstaller, cx_Freeze e auto-py-to-exe
Supporto alle sfide JavaScript VM di Cloudflare v3 - Gestisce la protezione Cloudflare più recente e sofisticata
Supporto alle sfide Turnstile di Cloudflare - Supporto per l'alternativa CAPTCHA di Cloudflare
Supporto potenziato per interpreti JavaScript - Migliore esecuzione delle sfide basate su VM
Copertura completa della protezione - Ora supporta tutti i tipi di sfide Cloudflare (v1, v2, v3, Turnstile)

🔧 Miglioramenti

🎯 Risolti problemi di User Agent negli eseguibili - Sistema di fallback automatico per browsers.json mancante
🛡️ Rilevamento PyInstaller - Rileva e gestisce automaticamente gli ambienti eseguibili
📦 Sistema di fallback completo - Oltre 70 user agent integrati che coprono tutte le piattaforme
Maggiori capacità di rotazione proxy e modalità stealth
Migliore rilevamento e gestione dei moderni meccanismi di protezione Cloudflare
Compatibilità migliorata con tutti gli interpreti JavaScript (js2py, nodejs, nativo)
Documentazione aggiornata con esempi completi

📊 Risultati dei test

Tutte le funzionalità testate con un tasso di successo del 100% per le funzionalità principali:

✅ Richieste di base: 100% di successo
✅ Gestione user agent: 100% di successo
✅ Sfide Cloudflare v1: 100% di successo
✅ Sfide Cloudflare v2: 100% di successo
✅ Sfide Cloudflare v3: 100% di successo
✅ Modalità stealth: 100% di successo

Un modulo Python per bypassare la pagina anti-bot di Cloudflare (nota anche come "I'm Under Attack Mode", o IUAM), implementato con Requests. Questa versione potenziata include il supporto per le sfide Cloudflare v2, la rotazione dei proxy, la modalità stealth e altro ancora. Cloudflare cambia periodicamente le proprie tecniche, quindi aggiornerò questo repository di frequente.

Questo può essere utile se desideri fare scraping o crawling di un sito web protetto da Cloudflare. La pagina anti-bot di Cloudflare attualmente controlla solo se il client supporta Javascript, anche se in futuro potrebbero aggiungere ulteriori tecniche.

Poiché Cloudflare modifica e rafforza costantemente la propria pagina di protezione, cloudscraper richiede un motore/interpreti JavaScript per risolvere le sfide Javascript. Ciò consente allo script di impersonare facilmente un normale browser web senza dover deoffuscare e analizzare esplicitamente il Javascript di Cloudflare.

Per riferimento, questo è il messaggio predefinito che Cloudflare utilizza per questo tipo di pagine:``` Checking your browser before accessing website.com.

This process is automatic. Your browser will redirect to your requested content shortly.

Please allow up to 5 seconds...

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

In alternativa, clona questo repository ed esegui python setup.py install.

Migrazione da cloudscraper

Se in precedenza utilizzavi il pacchetto originale cloudscraper, ora puoi usare direttamente questa versione potenziata:```python

Enhanced import

import cloudscraper # Enhanced version

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>..."

That's it...

Qualsiasi richiesta effettuata da questo oggetto sessione a siti web protetti dall'anti-bot di Cloudflare verrà gestita automaticamente. I siti web che non utilizzano Cloudflare verranno trattati normalmente. Non è necessario configurare o chiamare altro, e puoi trattare di fatto tutti i siti web come se non fossero protetti da nulla.

Usi cloudscraper esattamente nello stesso modo in cui usi Requests. cloudScraper funziona in modo identico a un oggetto Session di Requests, solo che invece di chiamare requests.get() o requests.post(), chiami scraper.get() o scraper.post().

Consulta la documentazione di Requests per maggiori informazioni.

✅ Compatibilità degli Eseguibili (v2.7.0)

Problema Risolto!

Il problema relativo allo user agent durante la conversione di applicazioni Python che usano cloudscraper in eseguibili è stato completamente risolto!

Qual era il problema?

Quando si convertono app Python in eseguibili (usando PyInstaller, cx_Freeze, auto-py-to-exe, ecc.), gli utenti incontravano errori relativi alla funzionalità user agent o agent_user perché il file browsers.json non veniva incluso correttamente.

La Soluzione

cloudscraper v2.7.0 include un sistema di fallback automatico:

Rilevamento PyInstaller - Rileva automaticamente gli ambienti eseguibili
Percorsi di fallback multipli - Prova diverse posizioni per browsers.json
Fallback integrato completo - 70+ user agent hardcoded che coprono tutte le piattaforme
Gestione elegante degli errori - Niente più crash quando i file mancano

Come Usare

Opzione 1: Crea semplicemente il tuo eseguibile (funziona automaticamente):```bash pyinstaller your_app.py

**Opzione 2: Includi il database completo degli user agent** (consigliata):```bash
pyinstaller --add-data "cloudscraper/user_agent/browsers.json;cloudscraper/user_agent/" your_app.py

Test

Tutta la compatibilità degli eseguibili è stata testata approfonditamente:``` ✅ Normal operation with browsers.json ✅ Fallback operation without browsers.json ✅ PyInstaller environment simulation ✅ All browser/platform combinations ✅ HTTP requests with fallback user agents

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)

Configurazione avanzata v3```python

import cloudscraper

Optimized configuration for v3 challenges

scraper = cloudscraper.create_scraper( interpreter='js2py', # Recommended for v3 challenges delay=5, # Allow more time for complex challenges debug=True # Enable debug output to see v3 detection )

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)}")

v3 Challenge Detection

Quando la modalità di debug è abilitata, vedrai il rilevamento della sfida v3 in azione:```python scraper = cloudscraper.create_scraper(debug=True) response = scraper.get("https://example.com")

Debug output will show:

"Detected a Cloudflare v3 JavaScript VM challenge."

### 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
)

🚀 Esempi completi

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

import cloudscraper

Create a scraper that handles all challenge types automatically

scraper = cloudscraper.create_scraper()

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

response = scraper.get("https://example.com") print(f"Status: {response.status_code}") print(f"Content length: {len(response.text)}")

### 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 3: Gestire Turnstile con risolutore CAPTCHA```python

import cloudscraper

Configure with 2captcha for Turnstile challenges

scraper = cloudscraper.create_scraper( captcha={ 'provider': '2captcha', 'api_key': 'your_2captcha_api_key' }, debug=True # See when Turnstile is detected and solved )

Turnstile challenges will be automatically detected and solved

response = scraper.get("https://turnstile-protected-site.com") print(f"Successfully bypassed Turnstile: {response.status_code}")

### 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}")

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

import cloudscraper

def test_challenge_handling(): """Test different challenge types with comprehensive configuration"""

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_challenge_handling()

## 🧪 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

Riepilogo dei Risultati dei Test

La libreria è stata testata approfonditamente con un tasso di successo del 100% per le funzionalità principali:

*Richiede configurazione esterna (proxy/chiavi API)

Test Manuale

Puoi testare manualmente la libreria con la modalità di debug per vedere il rilevamento delle sfide in azione:```python import cloudscraper

Enable debug mode to see what's happening

scraper = cloudscraper.create_scraper(debug=True) response = scraper.get("https://example.com")

Debug output will show:

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

- JavaScript interpreter used

- Challenge solving process

- Final response status

### 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
)

Options

Disable Cloudflare V1

Description

Se non vuoi nemmeno tentare la risoluzione di Cloudflare v1 (Deprecato)..

Parameters

Parametro	Valore	Predefinito
disableCloudflareV1	(boolean)	False

Example```python

scraper = cloudscraper.create_scraper(disableCloudflareV1=True)

### 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 Cloudflare V3

Descrizione

Se non vuoi nemmeno tentare di risolvere la VM JavaScript di Cloudflare v3..

Parametri

Parametro	Valore	Predefinito
disableCloudflareV3	(boolean)	False

Esempio```python

scraper = cloudscraper.create_scraper(disableCloudflareV3=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)

Rotazione Proxy

Descrizione

Ruota automaticamente attraverso un elenco di proxy per evitare il blocco basato sull'indirizzo IP.

Parametri

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

Parametri di `proxy_options`

Parametro	Valore	Predefinito
rotation_strategy	(stringa) `sequential`, `random` o

Esempio```python

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

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

### 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
    }
)

Brotli

Descrizione

È stato aggiunto il supporto alla decompressione Brotli, ed è abilitato per impostazione predefinita.

Parametri

Parametro	Valore	Predefinito
allow_brotli	(boolean)	True

Esempio```python

scraper = cloudscraper.create_scraper(allow_brotli=False)

### 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')

o```python

will give you only mobile chrome User-Agents on Android

scraper = cloudscraper.create_scraper( browser={ 'browser': 'chrome', 'platform': 'android', 'desktop': False } )

will give you only desktop firefox User-Agents on Windows

scraper = cloudscraper.create_scraper( browser={ 'browser': 'firefox', 'platform': 'windows', 'mobile': False } )

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.

scraper = cloudscraper.create_scraper( browser={ 'custom': 'ScraperBot/1.0', } )

### 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)

Ritardi

Descrizione

La sfida IUAM di Cloudflare richiede che il browser attenda ~5 secondi prima di inviare la risposta alla sfida, se si desidera ignorare questo ritardo.

Parametri

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

Parametro	Valore	Predefinito
delay	(float)	estratto dalla pagina IUAM

Esempio```python

scraper = cloudscraper.create_scraper(delay=10)

### 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

Purtroppo, non tutti gli attributi della sessione di Requests sono facilmente trasferibili, quindi se incontri problemi con questo,

Dovresti sostituire la tua chiamata iniziale di inizializzazione della sessione

Da:```python sess = requests.session()

A:```python
sess = cloudscraper.create_scraper()

Motori e Interpreti JavaScript

Descrizione

cloudscraper attualmente supporta i seguenti motori/interpreti JavaScript

ChakraCore
js2py (Predefinito nella versione avanzata)
native: Solver Python nativo autocostruito
Node.js
V8

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
interpreter	(string)	`js2py`

Esempio```python

scraper = cloudscraper.create_scraper(interpreter='nodejs')

#### 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')

2captcha

Parametri `captcha` richiesti

Nota

se i proxy sono impostati, puoi disabilitare l'invio dei proxy a 2captcha impostando no_proxy su True

Esempio```python

scraper = cloudscraper.create_scraper( captcha={ 'provider': '2captcha', 'api_key': 'your_2captcha_api_key' } )

#### 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'
  }
)

CapSolver

Parametri `captcha` obbligatori

Parametro	Valore	Obbligatorio	Predefinito
provider	(string) `captchaai`	sì
api_key	(string)	sì

Esempio```python

scraper = cloudscraper.create_scraper( captcha={ 'provider': 'capsolver', 'api_key': 'your_captchaai_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'
  }
)

deathbycaptcha

Parametri `captcha` obbligatori

Esempio```python

scraper = cloudscraper.create_scraper( captcha={ 'provider': 'deathbycaptcha', 'username': 'your_deathbycaptcha_username', 'password': 'your_deathbycaptcha_password', } )

#### 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
  }
)

return_response

Usalo se vuoi ottenere il payload di risposta della richiesta senza risolvere il Captcha.

Parametri `captcha` richiesti

Parametro	Valore	Obbligatorio	Predefinito
provider	(string) `return_response`	sì

Esempio```python

scraper = cloudscraper.create_scraper( captcha={'provider': 'return_response'} )

## 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
    }
)

get_cookie_string è una funzione di convenienza per restituire i token come stringa da usare come valore dell'intestazione HTTP Cookie.

Ciò è utile quando si crea manualmente una richiesta HTTP, o si lavora con un'applicazione esterna o una libreria che inoltra intestazioni cookie grezze.```python import cloudscraper

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

print('GET / HTTP/1.1\nCookie: {}\nUser-Agent: {}\n'.format(cookie_value, user_agent))

GET / HTTP/1.1

Cookie: cf_clearance=c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600; __cfduid=dd8ec03dfdbcb8c2ea63e920f1335c1001426733158

User-Agent: Some/User-Agent String

#### 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'
    ]
)

Versione ridotta. Stampa il contenuto delle pagine di qualsiasi sito protetto da Cloudflare, tramite curl.

Avvertenza: shell=True può essere pericoloso da usare con subprocess in codice reale.```python url = "http://somesite.com" cookie_arg, user_agent = cloudscraper.get_cookie_string(url) cmd = "curl --cookie {cookie_arg} -A {user_agent} {url}" print( subprocess.check_output( cmd.format( cookie_arg=cookie_arg, user_agent=user_agent, url=url ), shell=True ) )

### 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')

Il contenuto da tradurre non è stato fornito: la sezione INPUT è vuota. Non è possibile produrre una traduzione senza il testo sorgente.```python

Manipulate server_hostname

scraper = cloudscraper.create_scraper(server_hostname='www.somesite.com') scraper.get( 'https://backend.hosting.com/', headers={'Host': 'www.somesite.com'} )

# 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)

📋 Changelog

Versione 2.6.0 (Ultima) 🚀

🆕 Nuove funzionalità principali

Supporto per le sfide JavaScript VM v3 di Cloudflare
- Aggiunto supporto completo per le ultime sfide v3 di Cloudflare
- Le sfide vengono eseguite all'interno di una JavaScript Virtual Machine per una maggiore sicurezza
- Rilevamento automatico e gestione dei pattern delle sfide v3
- Supporto per tutti gli interpreti JavaScript (js2py, nodejs, native)
- Meccanismi di fallback potenziati per sfide VM complesse
Supporto Turnstile potenziato
- Migliorato il rilevamento delle sfide Turnstile di Cloudflare
- Migliore integrazione con i servizi di risoluzione CAPTCHA
- Supporto per tutti i principali provider CAPTCHA (2captcha, anticaptcha, ecc.)

🔧 Miglioramenti

Potenziamenti dell'interprete JavaScript
- Migliore compatibilità con le sfide VM v3 di JavaScript
- Migliorata la gestione degli errori e i meccanismi di fallback
- Creazione del contesto potenziata per le sfide basate su VM
Rilevamento delle sfide
- Rilevamento più accurato dei diversi tipi di sfida
- Migliore differenziazione tra sfide v1, v2, v3 e Turnstile
- Pattern regex migliorati per la protezione Cloudflare moderna
Opzioni di configurazione
- Aggiunto il parametro disableCloudflareV3 per la gestione selettiva delle sfide
- Output di debug potenziato per il rilevamento delle sfide v3
- Messaggi di errore e informazioni di risoluzione dei problemi migliorati

🧪 Test e qualità

Suite di test completa
- Tasso di successo del 100% per tutte le funzionalità principali
- Script di test dedicato per le sfide v3
- Copertura dei test potenziata per tutti i tipi di sfida
- Test automatizzati per tutti gli interpreti JavaScript
Documentazione
- Riscrittura completa del README con esempi per v3
- Aggiunti esempi d'uso completi
- Guida alla risoluzione dei problemi potenziata
- Aggiunta sezione su test e verifica

🐛 Correzioni di bug

Corretti problemi di compatibilità con le moderne sfide Cloudflare
Migliorata la gestione degli errori per i casi limite
Migliore gestione delle sfide JavaScript malformate
Gestione dei cookie potenziata per le implementazioni Cloudflare più recenti

Versione 2.5.3

Funzionalità aggiunte

Supporto iniziale per le sfide Turnstile
Capacità di rotazione dei proxy potenziate
Migliorata la funzionalità della modalità stealth
Migliore fingerprinting del browser

Versione 2.5.0

Modifiche principali

Consolidamento del codebase in un unico modulo
Supporto potenziato per le sfide v2
Migliore gestione dell'interprete JavaScript
Aggiunta suite di test completa

Crediti

cloudscraper originale di VeNoMouS
Edizione potenziata di Zied Boughdir

Test

La libreria include script di test completi per verificare la funzionalità:

Test di base

Test rapido per verificare che la libreria funzioni:```python import cloudscraper

Create a scraper instance

scraper = cloudscraper.create_scraper(browser='chrome')

Make a request to a Cloudflare-protected site

response = scraper.get('https://example.com') print(f"Status code: {response.status_code}")

### 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

Suggerimenti per la risoluzione dei problemi

Se riscontri problemi:

Prova un'emulazione browser diversa - Alcuni siti funzionano meglio con Chrome piuttosto che con Firefox
Attiva la modalità stealth - Aiuta a bypassare protezioni sofisticate
Usa la rotazione dei proxy - Per blocchi IP o limiti di frequenza
Prova diversi interpreti JavaScript - js2py, nodejs o v8

Supporto

Per problemi o domande, apri una issue sul repository GitHub.```bash pip install --upgrade cloudscraper # Always use the latest version

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*

provider	(stringa) `2captcha`	sì
api_key	(stringa)	sì
no_proxy	(booleano)	no	False

provider	(string) `deathbycaptcha`	sì
username	(string)	sì
password	(string)	sì

cloudscraper

Più Popolari

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