How to Bypass Cloudflare Anti-Bot Protection
with Mobile Proxies in 2026

# Create virtual environment
python -m venv cloudflare-bypass
source cloudflare-bypass/bin/activate

# Install Camoufox and dependencies
pip install camoufox[geoip]
pip install beautifulsoup4 lxml

# Camoufox downloads its patched Firefox binary on first run
python -c "from camoufox.sync_api import Camoufox; print('Camoufox ready')"

"""
Cloudflare bypass scraper using Camoufox + PROXIES.SX mobile proxies.
Handles AI Labyrinth detection, Turnstile challenges, and TLS fingerprinting.
"""

import time
import random
import json
from typing import Optional
from bs4 import BeautifulSoup
from camoufox.sync_api import Camoufox


# ─── Configuration ───────────────────────────────────────────────
PROXY_HOST = "us.proxies.sx"
PROXY_PORT = 5057
PROXY_USER = "your_username"
PROXY_PASS = "your_password"

TARGET_URL = "https://example-cloudflare-protected.com/products"

# Anti-detection settings
MIN_DELAY = 2.0    # Minimum seconds between actions
MAX_DELAY = 5.0    # Maximum seconds between actions
PAGE_TIMEOUT = 30  # Seconds to wait for page load


# ─── AI Labyrinth Detection ────────────────────────────────────
def is_labyrinth_page(page) -> bool:
    """
    Detect if the current page is an AI Labyrinth honeypot.
    Labyrinth pages have telltale signs:
    - Hidden links with data-cf-* attributes
    - Unnaturally dense internal link structures
    - Content that doesn't match the site's real schema
    """
    # Check for Cloudflare honeypot markers
    honeypot_links = page.query_selector_all(
        'a[href*="/cdn-cgi/"], '
        'a[style*="display:none"], '
        'a[style*="visibility:hidden"], '
        'a[style*="opacity:0"]'
    )
    if len(honeypot_links) > 5:
        print("[WARN] Possible AI Labyrinth detected: hidden links found")
        return True

    # Check for abnormal link density (labyrinth pages are link-heavy)
    all_links = page.query_selector_all('a[href]')
    text_content = page.inner_text('body')
    words = len(text_content.split())
    if words > 0 and len(all_links) / words > 0.1:
        print("[WARN] Abnormal link-to-text ratio detected")
        return True

    return False


# ─── Human-Like Behavior Simulation ───────────────────────────
def human_delay(min_s: float = MIN_DELAY, max_s: float = MAX_DELAY):
    """Random delay with normal distribution for realistic timing."""
    delay = random.uniform(min_s, max_s)
    # Occasionally add a longer "reading" pause
    if random.random() < 0.15:
        delay += random.uniform(3.0, 8.0)
    time.sleep(delay)


def human_scroll(page):
    """Simulate human-like scrolling patterns."""
    viewport_height = page.viewport_size['height']
    page_height = page.evaluate('document.body.scrollHeight')

    current_pos = 0
    while current_pos < page_height * 0.7:
        # Variable scroll distance (humans don't scroll uniformly)
        scroll_delta = random.randint(
            int(viewport_height * 0.3),
            int(viewport_height * 0.8)
        )
        current_pos += scroll_delta
        page.evaluate(f'window.scrollTo({{top: {current_pos}, behavior: "smooth"}})')
        # Pause to "read" content
        time.sleep(random.uniform(0.5, 2.0))


# ─── Main Scraper ─────────────────────────────────────────────
def scrape_cloudflare_site(url: str) -> Optional[dict]:
    """
    Scrape a Cloudflare-protected page using Camoufox + mobile proxy.

    Returns extracted data or None if blocked.
    """
    proxy_config = {
        "server": f"socks5://{PROXY_HOST}:{PROXY_PORT}",
        "username": PROXY_USER,
        "password": PROXY_PASS,
    }

    # Launch Camoufox with mobile proxy and stealth settings
    with Camoufox(
        headless=False,        # Headed mode is less detectable
        proxy=proxy_config,
        geoip=True,            # Match geolocation to proxy IP
        humanize=True,         # Enable human-like behavior patches
    ) as browser:
        page = browser.new_page()

        # Set realistic viewport (mobile-like dimensions)
        page.set_viewport_size({"width": 1366, "height": 768})

        print(f"[INFO] Navigating to {url}")
        try:
            # Navigate with extended timeout for Cloudflare challenges
            page.goto(url, timeout=PAGE_TIMEOUT * 1000, wait_until="domcontentloaded")
        except Exception as e:
            print(f"[ERROR] Navigation failed: {e}")
            return None

        # Wait for potential Turnstile challenge to resolve
        # Camoufox handles Turnstile automatically in most cases
        time.sleep(random.uniform(3.0, 6.0))

        # Check if we hit a Cloudflare challenge page
        if "challenge" in page.url or "cdn-cgi" in page.url:
            print("[INFO] Cloudflare challenge detected, waiting for resolution...")
            try:
                page.wait_for_url(f"**/{url.split('/')[-1]}**", timeout=15000)
            except Exception:
                print("[ERROR] Challenge not resolved within timeout")
                return None

        # Check for AI Labyrinth
        if is_labyrinth_page(page):
            print("[ABORT] AI Labyrinth detected - stopping to avoid fingerprint burn")
            return None

        # Simulate human browsing behavior
        human_delay(1.0, 3.0)
        human_scroll(page)

        # Extract page content
        html = page.content()
        soup = BeautifulSoup(html, 'lxml')

        # Extract structured data (customize for your target)
        data = {
            "url": page.url,
            "title": soup.title.string if soup.title else None,
            "status": "success",
            "content_length": len(html),
        }

        # Example: extract product data
        products = []
        for item in soup.select('.product-card, [data-product]'):
            product = {
                "name": item.select_one('.product-name, h2, h3'),
                "price": item.select_one('.price, [data-price]'),
            }
            product["name"] = product["name"].get_text(strip=True) if product["name"] else None
            product["price"] = product["price"].get_text(strip=True) if product["price"] else None
            if product["name"]:
                products.append(product)

        data["products"] = products
        data["product_count"] = len(products)

        print(f"[SUCCESS] Extracted {len(products)} products from {url}")
        return data


# ─── Multi-Page Scraping with Rate Limiting ───────────────────
def scrape_multiple_pages(urls: list[str]) -> list[dict]:
    """Scrape multiple Cloudflare-protected pages with proper rate limiting."""
    results = []

    for i, url in enumerate(urls):
        print(f"\n[{i+1}/{len(urls)}] Processing: {url}")

        result = scrape_cloudflare_site(url)
        if result:
            results.append(result)
        else:
            print(f"[SKIP] Failed to scrape {url}")

        # Rate limiting between pages (critical for Cloudflare)
        if i < len(urls) - 1:
            delay = random.uniform(8.0, 15.0)
            print(f"[WAIT] Sleeping {delay:.1f}s before next request...")
            time.sleep(delay)

    return results


# ─── Entry Point ──────────────────────────────────────────────
if __name__ == "__main__":
    urls = [
        "https://example-cloudflare-protected.com/products?page=1",
        "https://example-cloudflare-protected.com/products?page=2",
        "https://example-cloudflare-protected.com/products?page=3",
    ]

    results = scrape_multiple_pages(urls)

    # Save results
    with open("scraped_data.json", "w") as f:
        json.dump(results, f, indent=2)

    print(f"\nDone. Scraped {len(results)}/{len(urls)} pages successfully.")

"""Quick verification script for proxy + fingerprint."""

from camoufox.sync_api import Camoufox

PROXY = {
    "server": "socks5://us.proxies.sx:5057",
    "username": "your_username",
    "password": "your_password",
}

with Camoufox(proxy=PROXY, geoip=True, humanize=True) as browser:
    page = browser.new_page()

    # Check IP address
    page.goto("https://api.ipify.org?format=json")
    ip_data = page.inner_text("body")
    print(f"Your IP: {ip_data}")

    # Check TLS fingerprint
    page.goto("https://tls.browserleaks.com/json")
    tls_data = page.inner_text("body")
    print(f"TLS Fingerprint: {tls_data[:200]}...")

    # Check bot detection score
    page.goto("https://abrahamjuliot.github.io/creepjs/")
    import time; time.sleep(5)
    trust_score = page.query_selector('.trust-score')
    if trust_score:
        print(f"CreepJS Trust Score: {trust_score.inner_text()}")

    print("\nSetup verified. Ready to scrape.")