Tout script utilisant cloudscraper fera une pause d'environ 5 secondes lors de la première visite d'un site dont les anti-bots Cloudflare sont activés, mais aucun délai ne surviendra après la première requête.



# Installation

Il suffit d'exécuter `pip install cloudscraper`. Le paquet PyPI est disponible sur https://pypi.org/project/cloudscraper/```bash
pip install cloudscraper

L'API reste compatible, vous n'avez donc qu'à modifier les instructions d'importation dans votre code. Tous les appels de fonction et paramètres fonctionnent de la même manière.

### Structure de la base de code

La base de code a été simplifiée pour améliorer la maintenabilité et réduire la confusion :

- **Module unique** : Tout le code se trouve désormais dans le module `cloudscraper`
- **Redondance supprimée** : Les répertoires redondants ont été supprimés
- **Tests mis à jour** : Tous les fichiers de test ont été mis à jour pour utiliser le module `cloudscraper`

Cela rend la base de code plus propre et plus facile à maintenir tout en assurant une rétrocompatibilité avec le code existant qui utilise l'API d'origine.

## Fonctionnalités clés de cloudscraper

| Fonctionnalité | Description | Statut |
|---------|-------------|--------|
| **🆕 Compatibilité des exécutables** | Correction complète pour la conversion PyInstaller, cx_Freeze, auto-py-to-exe | ✅ **CORRIGÉ** |
| **🆕 Défis JavaScript VM v3** | Prise en charge des derniers défis basés sur la machine virtuelle JavaScript de Cloudflare | ✅ **NOUVEAU** |
| **🆕 Support Turnstile** | Prise en charge du nouveau remplacement de CAPTCHA Turnstile de Cloudflare | ✅ **NOUVEAU** |
| **Support des défis modernes** | Prise en charge améliorée des défis Cloudflare v1, v2, v3 et Turnstile | ✅ Complet |
| **Rotation de proxys** | Rotation intelligente intégrée des proxys avec plusieurs stratégies | ✅ Amélioré |
| **Mode furtif** | Simulation de comportement humain pour éviter la détection | ✅ Amélioré |
| **Émulation de navigateur** | Empreinte numérique avancée du navigateur pour Chrome et Firefox | ✅ Stable |
| **Gestion JavaScript** | Meilleur interpréteur JS (js2py par défaut) pour résoudre les défis | ✅ Amélioré |
| **Solveurs de CAPTCHA** | Prise en charge de plusieurs services de résolution de CAPTCHA | ✅ Stable |

# Dépendances

- **Python 3.8+** (Prise en charge abandonnée pour Python 3.6 et 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` installera automatiquement les dépendances Python. Les interpréteurs et/ou moteurs JavaScript que vous décidez d'utiliser sont les seuls éléments que vous devez installer vous-même, à l'exception de js2py qui fait partie des exigences par défaut.

# Interpréteurs et moteurs JavaScript

Nous prenons en charge les interpréteurs/moteurs JavaScript suivants.

- **[ChakraCore](https://github.com/microsoft/ChakraCore):** Les binaires de la bibliothèque peuvent également être situés [ici](https://www.github.com/VeNoMouS/cloudscraper/tree/ChakraCore/).
- **[js2py](https://github.com/PiotrDabkowski/Js2Py):** >=0.74 **(Par défaut pour la version améliorée)**
- **native**: Solveur Python natif fait maison
- **[Node.js](https://nodejs.org/)**
- **[V8](https://github.com/sony/v8eval/):** Nous utilisons le module Python [v8eval](https://v8.dev)() de Sony.

# Utilisation

La façon la plus simple d'utiliser cloudscraper est d'appeler `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>..."

**Option 2: Inclure la base de données complète des user agents** (recommandé):```bash
pyinstaller --add-data "cloudscraper/user_agent/browsers.json;cloudscraper/user_agent/" your_app.py

Vos applications cloudscraper fonctionneront désormais parfaitement lorsqu'elles seront converties en exécutables ! 🎉

## 🆕 Prise en charge des challenges JavaScript VM Cloudflare v3

### Que sont les challenges v3 ?

Les challenges v3 de Cloudflare représentent la dernière évolution de la technologie de protection contre les bots. Contrairement aux challenges v1 et v2 traditionnels, les challenges v3 :

- **S'exécutent dans une machine virtuelle JavaScript** : Les challenges s'exécutent dans un environnement JavaScript sandboxé
- **Utilisent une détection avancée** : Des algorithmes plus sophistiqués pour détecter les comportements automatisés
- **Génèrent du code dynamique** : Le code du challenge est créé dynamiquement et plus difficile à rétro-ingénierer
- **Offrent une protection moderne** : La technologie anti-bot la plus récente de Cloudflare

### Utilisation de base des v3```python
import cloudscraper

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

### v3 avec différents interpréteurs JavaScript

Tous les interpréteurs JavaScript fonctionnent avec les défis 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)}")

### Considérations de performance pour v3

Les défis v3 sont plus complexes et peuvent nécessiter plus de temps :```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
)

### Exemple 2 : Configuration avancée pour une compatibilité maximale```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")

### Exemple 4 : Rotation de proxy avec support 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)}")

## 🧪 Tests et vérification

### Suite de tests complète

cloudscraper comprend des scripts de tests complets pour vérifier que toutes les fonctionnalités fonctionnent correctement :```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

### Dépannage

Si vous rencontrez des problèmes :

1. **Activez le mode débogage** pour voir des informations détaillées
2. **Essayez différents interpréteurs** (js2py, nodejs, native)
3. **Augmentez le délai** pour les défis complexes
4. **Activez le mode furtif** pour une protection supplémentaire
5. **Vérifiez la configuration du proxy** si vous utilisez des proxys```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
)

### Désactiver Cloudflare V2
#### Description

Si vous ne voulez même pas tenter de résoudre Cloudflare v2..

#### Paramètres

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|disableCloudflareV2|(boolean)|False|

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

### Désactiver Turnstile
#### Description

Si vous ne voulez même pas tenter de résoudre le Turnstile Cloudflare..

#### Paramètres


|Paramètre|Valeur|Par défaut|
|-------------|:-------------:|:-----:|
|disableTurnstile|(boolean)|False|

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

### Mode furtif
#### Description

Activer des techniques furtives pour mieux imiter le comportement humain et éviter la détection.

#### Paramètres

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|enable_stealth|(boolean)|True|
|stealth_options|(dict)|{}|

#### Paramètres de `stealth_options`

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|max_delay|(float) délai maximum entre les requêtes|5.0|
|min_delay|(float) délai minimum entre les requêtes|1.0|
|human_like_delays|(boolean) ajouter des délais aléatoires entre les requêtes|True|
|randomize_headers|(boolean) randomiser les en-têtes pour éviter le fingerprinting|True|
|browser_quirks|(boolean) appliquer les particularités spécifiques au navigateur|True|

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

### Filtrage du navigateur / User-Agent

#### Description

Contrôlez comment et quel User-Agent est sélectionné "aléatoirement".

#### Paramètres

Peut être passé comme argument à `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|browser|(string) `chrome` ou `firefox`|None|

Ou

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|browser|(dict)||

##### `browser` *_dict_* Paramètres
|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|browser|(string) `chrome` ou `firefox`|None|
|mobile|(boolean)|True|
|desktop|(boolean)|True|
|platform|(string) `'linux', 'windows', 'darwin', 'android', 'ios'`|None|
|custom|(string)|None|
#### Exemple```python
scraper = cloudscraper.create_scraper(browser='chrome')

### Débogage

#### Description

Affiche les informations d'en-tête et de contenu de la requête à des fins de débogage.

#### Paramètres

Peut être défini comme un attribut via votre objet `cloudscraper` ou passé comme argument à `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|debug|(boolean)|False|

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

### Session existante

#### Description:

Si vous disposez déjà d'une session Requests existante, vous pouvez la passer à la fonction `create_scraper()` pour continuer à utiliser cette session.

#### Paramètres

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|sess|(requests.session)|None|

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

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

#### Note

La version améliorée utilise `js2py` comme interpréteur par défaut car il offre une meilleure compatibilité avec les défis Cloudflare modernes. Si vous rencontrez des problèmes, vous pouvez essayer d'autres interpréteurs.

------

### Solveurs de Captcha Tiers

#### Description
`cloudscraper` prend actuellement en charge les solveurs de Captcha tiers suivants, si vous en avez besoin.

- **[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__**

#### Note

Je travaille à l'ajout d'autres solveurs tiers. Si vous souhaitez qu'un service non pris en charge actuellement soit ajouté, veuillez ouvrir un ticket de support sur github.

##### Paramètres requis

Ils peuvent être définis comme attribut via votre objet `cloudscraper` ou transmis comme argument à `create_scraper()`, `get_tokens()`, `get_cookie_string()`.

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|captcha|(dict)|None|

#### Prise en charge de Turnstile

Cloudflare Turnstile est une nouvelle alternative au CAPTCHA qui remplace les CAPTCHA traditionnels par un système de vérification plus convivial. cloudscraper prend désormais en charge la résolution des défis Turnstile en utilisant les mêmes fournisseurs de captcha que vous connaissez déjà.

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

##### Paramètres `captcha` requis

|Paramètre|Valeur|Requis|Défaut|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `anticaptcha`|oui||
|api_key|(string)|oui||
|no_proxy|(boolean)|non|False|

##### Note

si des proxys sont définis, vous pouvez désactiver l'envoi des proxys à anticaptcha en définissant `no_proxy` sur `True`

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

------

#### CapMonster Cloud

##### Paramètres `captcha` requis

|Paramètre|Valeur|Requis|Défaut|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `capmonster`| oui||
|clientKey|(string)| oui||
|no_proxy|(boolean)|non|False|

##### Remarque

si des proxys sont définis, vous pouvez désactiver l'envoi des proxys à CapMonster en définissant `no_proxy` sur `True`

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

#### 9kw

##### Paramètres `captcha` requis

|Paramètre|Valeur|Requis|Défaut|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `9kw`|oui||
|api_key|(string)|oui||
|maxtimeout|(int)|non|180|

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

## Intégration

Il est facile d'intégrer `cloudscraper` avec d'autres applications et outils. Cloudflare utilise deux cookies comme jetons : l'un pour vérifier que vous avez dépassé leur page de défi et l'autre pour suivre votre session. Pour contourner la page de défi, incluez simplement ces deux cookies (avec le user-agent approprié) dans toutes les requêtes HTTP que vous effectuez.

Pour récupérer uniquement les cookies (sous forme de dictionnaire), utilisez `cloudscraper.get_tokens()`. Pour les récupérer sous forme d'en-tête HTTP `Cookie` complet, utilisez `cloudscraper.get_cookie_string()`.

`get_tokens` et `get_cookie_string` acceptent tous deux les arguments de mot-clé habituels de Requests (comme `get_tokens(url, proxies={"http": "socks5://localhost:9050"})`).

Veuillez lire [la documentation de Requests sur les arguments de requête](http://docs.python-requests.org/en/master/api/#requests.Session.request) pour plus d'informations.

------

### Gestion du User-Agent

Les deux fonctions d'intégration renvoient un tuple `(cookie, user_agent_string)`.

**Vous devez utiliser la même chaîne user-agent pour obtenir les jetons et pour faire des requêtes avec ces jetons, sinon Cloudflare vous signalera comme un bot.**

Cela signifie que vous devez transmettre la `user_agent_string` renvoyée à tout script, outil ou service auquel vous transmettez les jetons (par exemple curl, ou un outil de scraping spécialisé), et il doit utiliser ce user-agent transmis lorsqu'il effectue des requêtes HTTP.

------

### Exemples d'intégration

Rappelez-vous, vous devez toujours utiliser le même user-agent lors de la récupération ou de l'utilisation de ces cookies. Ces fonctions renvoient toutes un tuple `(cookie_dict, user_agent_string)`.

------

#### Récupération d'un dictionnaire de cookies via un proxy

`get_tokens` est une fonction pratique pour renvoyer un dict Python contenant les cookies de session de Cloudflare. Pour la démonstration, nous allons configurer cette requête pour utiliser un proxy. (Veuillez noter que si vous demandez des jetons de contournement Cloudflare via un proxy, vous devez toujours utiliser le même proxy lorsque ces jetons sont transmis au serveur. Cloudflare exige que l'adresse IP de résolution du défi et l'adresse IP du visiteur restent identiques.)

Si vous ne souhaitez pas utiliser de proxy, ne passez simplement pas l'argument de mot-clé `proxies`. Ces fonctions pratiques prennent en charge tous les arguments de mot-clé normaux de Requests, comme `params`, `data` et `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
    }
)

#### curl exemple

Voici un exemple d'intégration de cloudscraper avec curl. Comme vous pouvez le voir, tout ce que vous avez à faire est de passer les cookies et le user-agent à 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'
    ]
)

### Cryptographie

#### Description

Contrôler la communication entre le client et le serveur

#### Paramètres

Peut être passé comme argument à `create_scraper()`.

|Paramètre|Valeur|Défaut|
|-------------|:-------------:|:-----:|
|cipherSuite|(string)|None|
|ecdhCurve|(string)|prime256v1|
|server_hostname|(string)|None|

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

# Fonctionnalités améliorées

Cette version améliorée de cloudscraper offre de meilleures capacités pour contourner les mécanismes modernes de protection Cloudflare:

1. **Prise en charge des défis Cloudflare v2** - Meilleure gestion des défis modernes
2. **Rotation de proxys** - Rotation intelligente avec plusieurs stratégies
3. **Mode furtif** - Simulation d'un comportement humain
4. **Meilleure gestion de JavaScript** - Meilleur interpréteur JS (js2py par défaut)
5. **Gestion améliorée des cookies** - Prise en charge des nouveaux types de cookies Cloudflare

## Mises à jour récentes

- **Nettoyage de la base de code**: Suppression du code redondant et consolidation en un seul module
- **Mises à jour de la suite de tests**: Tous les tests utilisent désormais le module cloudscraper
- **Documentation**: README amélioré avec des exemples plus clairs et des instructions d'utilisation

## Exemple utilisant toutes les fonctionnalités améliorées```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)

### Exécution de la suite de tests

La bibliothèque comprend plusieurs scripts de 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