DataDome & Akamai Bypass Guide
Mobile Proxies for Anti-Bot in 2026

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

# Alternative: install Nodriver for Chrome-based approach
pip install nodriver

# Verify installation
python -c "from camoufox.sync_api import Camoufox; print('Camoufox ready')"
camoufox fetch  # Download the patched Firefox binary

"""
DataDome Bypass: Camoufox + Mobile Proxy + Human Behavior Simulation
Requires: pip install camoufox[geoip] beautifulsoup4 lxml
"""

import random
import time
import math
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"

PAGE_TIMEOUT = 30        # seconds
MIN_DELAY = 1.5          # minimum delay between actions
MAX_DELAY = 4.0          # maximum delay between actions


# ─── Human-Like Mouse Movement ───────────────────────────────
def human_mouse_move(page, target_x: int, target_y: int):
    """
    Move mouse to target using Bezier curve for natural movement.
    DataDome tracks mouse velocity, acceleration, and curvature.
    Straight-line movements are an instant red flag.
    """
    # Get current mouse position (default to random start)
    start_x = random.randint(100, 400)
    start_y = random.randint(100, 300)

    # Generate control points for Bezier curve
    cp1_x = start_x + random.randint(-50, 150)
    cp1_y = start_y + random.randint(-80, 80)
    cp2_x = target_x + random.randint(-100, 50)
    cp2_y = target_y + random.randint(-60, 60)

    # Number of steps (more = smoother, but slower)
    steps = random.randint(25, 45)

    for i in range(steps + 1):
        t = i / steps
        # Cubic Bezier curve
        x = int(
            (1 - t) ** 3 * start_x
            + 3 * (1 - t) ** 2 * t * cp1_x
            + 3 * (1 - t) * t ** 2 * cp2_x
            + t ** 3 * target_x
        )
        y = int(
            (1 - t) ** 3 * start_y
            + 3 * (1 - t) ** 2 * t * cp1_y
            + 3 * (1 - t) * t ** 2 * cp2_y
            + t ** 3 * target_y
        )

        page.mouse.move(x, y)

        # Variable delay between movements (humans are not constant)
        # Faster in the middle, slower at start and end
        speed_factor = 1 - 4 * (t - 0.5) ** 2  # parabolic speed
        delay = random.uniform(0.005, 0.02) * (1.5 - speed_factor)
        time.sleep(delay)


# ─── Human-Like Scrolling ────────────────────────────────────
def human_scroll(page):
    """
    Simulate natural scrolling. DataDome detects:
    - Perfectly uniform scroll distances
    - Constant scroll speed
    - No pauses between scrolls
    """
    viewport_height = page.viewport_size['height']
    page_height = page.evaluate('document.body.scrollHeight')

    current_pos = 0
    while current_pos < page_height * 0.65:
        # Variable scroll distance
        scroll_delta = random.randint(
            int(viewport_height * 0.2),
            int(viewport_height * 0.7)
        )
        current_pos += scroll_delta

        page.evaluate(
            f'window.scrollTo({{top: {current_pos}, behavior: "smooth"}})'
        )

        # Variable pause to "read" content
        if random.random() < 0.3:
            # Longer pause (reading something interesting)
            time.sleep(random.uniform(2.0, 5.0))
        else:
            time.sleep(random.uniform(0.4, 1.5))

        # Occasionally scroll back up slightly (natural behavior)
        if random.random() < 0.1:
            back_scroll = random.randint(50, 150)
            current_pos -= back_scroll
            page.evaluate(
                f'window.scrollTo({{top: {current_pos}, behavior: "smooth"}})'
            )
            time.sleep(random.uniform(0.5, 1.0))


# ─── Random Delay with Natural Distribution ──────────────────
def human_delay(min_s: float = MIN_DELAY, max_s: float = MAX_DELAY):
    """Random delay using log-normal distribution (more human-like)."""
    mean = (min_s + max_s) / 2
    sigma = (max_s - min_s) / 4
    delay = max(min_s, min(max_s, random.lognormvariate(
        math.log(mean), sigma / mean
    )))
    # Occasional longer "thinking" pause
    if random.random() < 0.12:
        delay += random.uniform(3.0, 7.0)
    time.sleep(delay)


# ─── Main Scraper ─────────────────────────────────────────────
def scrape_datadome_site(url: str) -> Optional[dict]:
    """
    Scrape a DataDome-protected page using Camoufox + mobile proxy.
    Includes human-like behavior to pass behavioral analysis.
    """
    proxy_config = {
        "server": f"socks5://{PROXY_HOST}:{PROXY_PORT}",
        "username": PROXY_USER,
        "password": PROXY_PASS,
    }

    with Camoufox(
        headless=False,        # Headed mode is less detectable
        proxy=proxy_config,
        geoip=True,            # Match geolocation to proxy IP
        humanize=True,         # Enable built-in humanization
    ) as browser:
        page = browser.new_page()
        page.set_viewport_size({"width": 1366, "height": 768})

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

        # Initial wait (let DataDome scripts load and run)
        time.sleep(random.uniform(2.0, 4.0))

        # Check for DataDome challenge (interstitial page)
        if page.query_selector('[data-datadome]') or \
           'datadome' in page.content().lower()[:2000]:
            print("[INFO] DataDome challenge detected, waiting...")
            try:
                page.wait_for_load_state("networkidle", timeout=10000)
            except Exception:
                pass
            time.sleep(random.uniform(2.0, 4.0))

        # ─── Human Behavior Simulation (Critical for DataDome) ───
        # Move mouse to a random area first
        human_mouse_move(
            page,
            random.randint(200, 800),
            random.randint(200, 500)
        )
        human_delay(0.5, 1.5)

        # Scroll through the page naturally
        human_scroll(page)

        # Move mouse to content area
        human_mouse_move(
            page,
            random.randint(300, 700),
            random.randint(150, 400)
        )
        human_delay(1.0, 2.5)

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

        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'):
            product = {
                "name": item.select_one(
                    '.product-name, .product-title, h2, h3'
                ),
                "price": item.select_one(
                    '.price, [data-price], .product-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)} items from {url}")
        return data


# ─── Multi-Page with Rate Limiting ────────────────────────────
def scrape_multiple(urls: list[str]) -> list[dict]:
    """Scrape multiple DataDome-protected pages."""
    results = []

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

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

        # Longer delays for DataDome (it tracks request patterns)
        if i < len(urls) - 1:
            delay = random.uniform(10.0, 20.0)
            print(f"[WAIT] Sleeping {delay:.1f}s...")
            time.sleep(delay)

    return results


# ─── Entry Point ──────────────────────────────────────────────
if __name__ == "__main__":
    import json

    urls = [
        "https://example-datadome-protected.com/products?page=1",
        "https://example-datadome-protected.com/products?page=2",
        "https://example-datadome-protected.com/products?page=3",
    ]

    results = scrape_multiple(urls)

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

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

"""Quick verification: proxy + fingerprint + behavior check."""

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

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

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

    # 3. Verify IP is not flagged by anti-bot databases
    page.goto("https://whatismyipaddress.com")
    page.wait_for_load_state("networkidle")
    print(f"IP lookup page loaded: {page.title()}")

    # 4. Check for known bot detection markers
    page.goto("https://bot.sannysoft.com")
    page.wait_for_load_state("networkidle")

    # Take screenshot for visual verification
    page.screenshot(path="bot_check.png")
    print("Bot detection check saved to bot_check.png")
    print("Review the screenshot - all tests should show GREEN")