Jedes Skript, das cloudscraper verwendet, wartet beim ersten Besuch einer Website mit aktiviertem Cloudflare-Anti-Bot-Schutz etwa 5 Sekunden, obwohl nach der ersten Anfrage keine Verzögerung mehr auftritt.

# Installation

Führen Sie einfach `pip install cloudscraper` aus. Das PyPI-Paket finden Sie unter https://pypi.org/project/cloudscraper/```bash
pip install cloudscraper

The API remains compatible, so you only need to change the import statements in your code. All function calls and parameters work the same way.

### Struktur der Codebasis

Die Codebasis wurde gestrafft, um die Wartbarkeit zu verbessern und Verwirrung zu reduzieren:

- **Einzelnes Modul**: Der gesamte Code befindet sich jetzt im Modul `cloudscraper`
- **Redundanz entfernt**: Die redundanten Verzeichnisse wurden entfernt
- **Aktualisierte Tests**: Alle Testdateien wurden aktualisiert, um das Modul `cloudscraper` zu verwenden

Dadurch wird die Codebasis übersichtlicher und einfacher zu warten, während die Abwärtskompatibilität mit vorhandenem Code erhalten bleibt, der die ursprüngliche API verwendet.

## Wichtige Funktionen in cloudscraper

| Funktion | Beschreibung | Status |
|---------|-------------|--------|
| **🆕 Executable-Kompatibilität** | Vollständige Lösung für PyInstaller-, cx_Freeze-, auto-py-to-exe-Konvertierung | ✅ **BEHOBEN** |
| **🆕 v3-JavaScript-VM-Herausforderungen** | Unterstützung für Cloudflares neueste JavaScript-VM-basierte Herausforderungen | ✅ **NEU** |
| **🆕 Turnstile-Unterstützung** | Unterstützung für Cloudflares neuen Turnstile-CAPTCHA-Ersatz | ✅ **NEU** |
| **Moderne Challenge-Unterstützung** | Erweiterte Unterstützung für v1-, v2-, v3- und Turnstile-Cloudflare-Challenges | ✅ Vollständig |
| **Proxy-Rotation** | Integrierte intelligente Proxy-Rotation mit mehreren Strategien | ✅ Erweitert |
| **Stealth-Modus** | Simulation menschenähnlichen Verhaltens, um Erkennung zu vermeiden | ✅ Erweitert |
| **Browser-Emulation** | Erweitertes Browser-Fingerprinting für Chrome und Firefox | ✅ Stabil |
| **JavaScript-Handhabung** | Besserer JS-Interpreter (js2py als Standard) zur Lösung von Challenges | ✅ Erweitert |
| **Captcha-Löser** | Unterstützung für mehrere CAPTCHA-Lösungsdienste | ✅ Stabil |

# Abhängigkeiten

- **Python 3.8+** (Unterstützung für Python 3.6 und 3.7 eingestellt)
- **[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` installiert die Python-Abhängigkeiten automatisch. Die JavaScript-Interpreter und/oder -Engines, die Sie verwenden möchten, sind das Einzige, was Sie selbst installieren müssen – abgesehen von js2py, das standardmäßig Teil der Anforderungen ist.

# JavaScript-Interpreter und -Engines

Wir unterstützen die folgenden JavaScript-Interpreter/-Engines.

- **[ChakraCore](https://github.com/microsoft/ChakraCore):** Bibliotheks-Binärdateien finden Sie auch [hier](https://www.github.com/VeNoMouS/cloudscraper/tree/ChakraCore/).
- **[js2py](https://github.com/PiotrDabkowski/Js2Py):** >=0.74 **(Standard für die erweiterte Version)**
- **native**: Selbstgebauter nativer Python-Solver
- **[Node.js](https://nodejs.org/)**
- **[V8](https://github.com/sony/v8eval/):** Wir verwenden Sonys [v8eval](https://v8.dev)()-Python-Modul.

# Verwendung

Der einfachste Weg, cloudscraper zu verwenden, ist der Aufruf von `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: Vollständige User-Agent-Datenbank einbeziehen** (empfohlen):```bash
pyinstaller --add-data "cloudscraper/user_agent/browsers.json;cloudscraper/user_agent/" your_app.py

Your cloudscraper-Anwendungen funktionieren jetzt einwandfrei, wenn sie in ausführbare Dateien konvertiert werden! 🎉

## 🆕 Unterstützung für Cloudflare v3 JavaScript-VM-Challenges

### Was sind v3-Challenges?

Cloudflare-v3-Challenges stellen die neueste Entwicklung der Bot-Schutz-Technologie dar. Im Gegensatz zu herkömmlichen v1- und v2-Challenges:

- **Laufen in einer JavaScript-VM**: Die Challenges werden in einer Sandbox-JavaScript-Umgebung ausgeführt
- **Nutzen erweiterte Erkennung**: Anspruchsvollere Algorithmen zur Erkennung automatisierten Verhaltens
- **Generieren dynamischen Code**: Der Challenge-Code wird dynamisch erstellt und ist schwerer zu reverse-engineeren
- **Bieten modernen Schutz**: Die aktuellste Anti-Bot-Technologie von Cloudflare

### Grundlegende v3-Nutzung```python
import cloudscraper

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

### v3 mit verschiedenen JavaScript-Interpretern

Alle JavaScript-Interpreter funktionieren mit v3-Herausforderungen:```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)}")

### Leistungsaspekte für v3

v3-Herausforderungen sind komplexer und können zusätzliche Zeit in Anspruch nehmen:```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
)

### Beispiel 2: Erweiterte Konfiguration für maximale Kompatibilität```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")

### Beispiel 4: Proxy-Rotation mit v3-Unterstützung```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 und Verifizierung

### Umfassende Testsuite

cloudscraper enthält umfassende Testskripte, um zu überprüfen, dass alle Funktionen korrekt funktionieren:```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

### Fehlerbehebung

Wenn Sie auf Probleme stoßen:

1. **Debug-Modus aktivieren**, um detaillierte Informationen zu sehen
2. **Verschiedene Interpreter ausprobieren** (js2py, nodejs, native)
3. **Verzögerung erhöhen** für komplexe Herausforderungen
4. **Stealth-Modus aktivieren** für zusätzlichen Schutz
5. **Proxy-Konfiguration prüfen**, wenn Sie Proxys verwenden```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
#### Beschreibung

Wenn Sie nicht einmal versuchen möchten, Cloudflare v2 zu lösen..

#### Parameter


|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|disableCloudflareV2|(boolean)|False|

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

### Turnstile deaktivieren
#### Beschreibung

Wenn Sie nicht einmal versuchen möchten, Cloudflare Turnstile zu lösen..

#### Parameter

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|disableTurnstile|(boolean)|False|

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

### Stealth-Modus
#### Beschreibung

Aktivieren Sie Stealth-Techniken, um menschliches Verhalten besser nachzuahmen und eine Erkennung zu vermeiden.

#### Parameter

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|enable_stealth|(boolean)|True|
|stealth_options|(dict)|{}|

#### `stealth_options` Parameter

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|min_delay|(float) Mindestverzögerung zwischen Anfragen|1.0|
|max_delay|(float) Maximalverzögerung zwischen Anfragen|5.0|
|human_like_delays|(boolean) zufällige Verzögerungen zwischen Anfragen hinzufügen|True|
|randomize_headers|(boolean) Header randomisieren, um Fingerprinting zu vermeiden|True|
|browser_quirks|(boolean) browserspezifische Eigenheiten anwenden|True|

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

### Browser- / User-Agent-Filterung

#### Beschreibung

Steuert, wie und welcher User-Agent „zufällig“ ausgewählt wird.

#### Parameter

Kann als Argument an `create_scraper()`, `get_tokens()`, `get_cookie_string()` übergeben werden.

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|browser|(string) `chrome` oder `firefox`|None|

Oder

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|browser|(dict)||

##### `browser` *_dict_* Parameter
|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|browser|(string) `chrome` oder `firefox`|None|
|mobile|(boolean)|True|
|desktop|(boolean)|True|
|platform|(string) `'linux', 'windows', 'darwin', 'android', 'ios'`|None|
|custom|(string)|None|
#### Beispiel```python
scraper = cloudscraper.create_scraper(browser='chrome')

### Debug

#### Beschreibung

Gibt Header- und Inhaltsinformationen der Anfrage zu Debugging-Zwecken aus.

#### Parameter

Kann als Attribut über dein `cloudscraper`-Objekt gesetzt oder als Argument an `create_scraper()`, `get_tokens()`, `get_cookie_string()` übergeben werden.

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|debug|(boolesch)|False|

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

### Vorhandene Sitzung

#### Beschreibung:

Wenn Sie bereits eine bestehende Requests-Sitzung haben, können Sie diese an die Funktion `create_scraper()` übergeben, um diese Sitzung weiterzuverwenden.

#### Parameter

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|sess|(requests.session)|None|

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

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

#### Hinweis

Die verbesserte Version verwendet `js2py` als Standard-Interpreter, da sie eine bessere Kompatibilität mit modernen Cloudflare-Challenges bietet. Wenn du auf Probleme stößt, kannst du andere Interpreter ausprobieren.

------

### Captcha-Löser von Drittanbietern

#### Beschreibung
`cloudscraper` unterstützt derzeit die folgenden Captcha-Löser von Drittanbietern, falls du sie benötigst.

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

#### Hinweis

Ich arbeite daran, weitere Drittanbieter-Löser hinzuzufügen. Wenn du einen Dienst hinzugefügt haben möchtest, der derzeit nicht unterstützt wird, erstelle bitte ein Support-Ticket auf github.

##### Erforderliche Parameter

Die Parameter können als Attribut über dein `cloudscraper`-Objekt gesetzt oder als Argument an `create_scraper()`, `get_tokens()`, `get_cookie_string()` übergeben werden.

|Parameter|Wert|Standardwert|
|-------------|:-------------:|:-----:|
|captcha|(dict)|None|

#### Turnstile-Unterstützung

Cloudflare Turnstile ist eine neue CAPTCHA-Alternative, die herkömmliche CAPTCHAs durch ein benutzerfreundlicheres Verifikationssystem ersetzt. cloudscraper unterstützt jetzt das Lösen von Turnstile-Challenges mit denselben Captcha-Anbietern, die du bereits kennst.

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

##### Erforderliche `captcha`-Parameter

|Parameter|Wert|Erforderlich|Standard|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `anticaptcha`|ja||
|api_key|(string)|ja||
|no_proxy|(boolean)|nein|False|

##### Hinweis

Wenn Proxys festgelegt sind, kannst du das Senden der Proxys an anticaptcha deaktivieren, indem du `no_proxy` auf `True` setzt.

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

#### CapMonster Cloud

##### Erforderliche `captcha` Parameter

|Parameter|Wert|Erforderlich|Standard|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `capmonster`| ja||
|clientKey|(string)| ja||
|no_proxy|(boolean)|nein|False|

##### Hinweis

Falls Proxys festgelegt sind, kann man das Senden der Proxys an CapMonster deaktivieren, indem man `no_proxy` auf `True` setzt.

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

#### 9kw

##### Erforderliche `captcha`-Parameter

|Parameter|Wert|Erforderlich|Standard|
|-------------|:-------------:|:-----:|:-----:|
|provider|(string) `9kw`|ja||
|api_key|(string)|ja||
|maxtimeout|(int)|nein|180|

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

## Integration

Es ist einfach, `cloudscraper` in andere Anwendungen und Werkzeuge zu integrieren. Cloudflare verwendet zwei Cookies als Tokens: eines, um zu überprüfen, dass du deren Challenge-Seite erfolgreich passiert hast, und eines, um deine Sitzung zu verfolgen. Um die Challenge-Seite zu umgehen, nimm einfach beide Cookies (mit dem passenden User-Agent) in alle HTTP-Anfragen auf, die du sendest.

Um nur die Cookies (als Dictionary) abzurufen, verwende `cloudscraper.get_tokens()`. Um sie als vollständigen `Cookie`-HTTP-Header abzurufen, verwende `cloudscraper.get_cookie_string()`.

`get_tokens` und `get_cookie_string` akzeptieren beide die üblichen Schlüsselwortargumente von Requests (z. B. `get_tokens(url, proxies={"http": "socks5://localhost:9050"})`).

Weitere Informationen findest du in der [Requests-Dokumentation zu Anfrageargumenten](http://docs.python-requests.org/en/master/api/#requests.Session.request).

------

### Umgang mit dem User-Agent

Die beiden Integrationsfunktionen geben ein Tupel aus `(cookie, user_agent_string)` zurück.

**Du musst denselben User-Agent-String sowohl zum Abrufen der Tokens als auch für Anfragen mit diesen Tokens verwenden, andernfalls markiert Cloudflare dich als Bot.**

Das bedeutet, du musst den zurückgegebenen `user_agent_string` an das jeweilige Skript, Werkzeug oder den Dienst übergeben, dem du die Tokens übergibst (z. B. curl oder ein spezialisiertes Scraping-Tool), und es muss diesen übergebenen User-Agent bei HTTP-Anfragen verwenden.

------

### Integrationsbeispiele

Denke daran, dass du beim Abrufen oder Verwenden dieser Cookies immer denselben User-Agent verwenden musst. Diese Funktionen geben alle ein Tupel aus `(cookie_dict, user_agent_string)` zurück.

------

#### Abrufen eines Cookie-Dicts über einen Proxy

`get_tokens` ist eine Komfortfunktion, die ein Python-Dict mit Cloudflares Sitzungs-Cookies zurückgibt. Zur Veranschaulichung konfigurieren wir diese Anfrage so, dass sie einen Proxy verwendet. (Bitte beachte: Wenn du Cloudflare-Clearance-Tokens über einen Proxy anforderst, musst du immer denselben Proxy verwenden, wenn diese Tokens an den Server übergeben werden. Cloudflare verlangt, dass die IP, die die Challenge löst, und die Besucher-IP identisch bleiben.)

Wenn du keinen Proxy verwenden möchtest, übergib einfach das Schlüsselwortargument `proxies` nicht. Diese Komfortfunktionen unterstützen alle üblichen Schlüsselwortargumente von Requests, wie `params`, `data` und `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-Beispiel

Hier ist ein Beispiel für die Integration von cloudscraper mit curl. Wie du siehst, musst du nur die Cookies und den User-Agent an curl übergeben.```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'
    ]
)

### Kryptografie

#### Beschreibung

Steuert die Kommunikation zwischen Client und Server

#### Parameter

Kann als Argument an `create_scraper()` übergeben werden.

|Parameter|Wert|Standard|
|-------------|:-------------:|:-----:|
|cipherSuite|(string)|None|
|ecdhCurve|(string)|prime256v1|
|server_hostname|(string)|None|

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

# Erweiterte Funktionen

Diese erweiterte Version von cloudscraper bietet bessere Fähigkeiten zur Umgehung moderner Cloudflare-Schutzmechanismen:

1. **Cloudflare-v2-Challenge-Unterstützung** - Bessere Handhabung moderner Challenges
2. **Proxy-Rotation** - Intelligente Rotation mit mehreren Strategien
3. **Stealth-Modus** - Simulation menschlichen Verhaltens
4. **Verbesserte JavaScript-Handhabung** - Besserer JS-Interpreter (js2py als Standard)
5. **Erweitertes Cookie-Management** - Unterstützung für neuere Cloudflare-Cookie-Typen

## Neueste Updates

- **Codebasis-Bereinigung**: Redundanter Code entfernt und in einem einzigen Modul konsolidiert
- **Test-Suite-Aktualisierungen**: Alle Tests verwenden jetzt das cloudscraper-Modul
- **Dokumentation**: Verbesserte README mit klareren Beispielen und Nutzungsanweisungen

## Beispiel mit allen erweiterten Funktionen```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)

### Ausführen der Testsuite

Die Bibliothek enthält mehrere Testskripte:```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