Automatisation du navigateur avec Antidetect

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service

# Antidetect browser exposes a debug port per profile
ANTIDETECT_DEBUG_PORT = 9222

options = Options()
options.debugger_address = f"127.0.0.1:{ANTIDETECT_DEBUG_PORT}"

# Connect to the running antidetect profile
driver = webdriver.Chrome(options=options)

# Now you control a fully spoofed browser
driver.get("https://browserleaks.com/canvas")
print(f"Title: {driver.title}")

# Verify fingerprint is spoofed
webdriver_flag = driver.execute_script(
    "return navigator.webdriver"
)
print(f"navigator.webdriver: {webdriver_flag}")
# Should be: undefined or false (antidetect patches this)

# Multi-profile example: loop through profiles
import requests

API_URL = "http://localhost:3001/api/v1"

# Get list of browser profiles from antidetect API
profiles = requests.get(f"{API_URL}/browser_profiles").json()

for profile in profiles[:5]:
    # Start profile with automation enabled
    resp = requests.get(
        f"{API_URL}/browser_profiles/{profile['id']}/start"
    ).json()
    port = resp["automation"]["port"]

    opts = Options()
    opts.debugger_address = f"127.0.0.1:{port}"
    d = webdriver.Chrome(options=opts)

    d.get("https://example.com")
    print(f"Profile {profile['name']}: {d.title}")

    d.quit()

const puppeteer = require('puppeteer-core');

const ANTIDETECT_WS = 'ws://127.0.0.1:9222/devtools/browser';

async function automateProfile() {
  // Connect to antidetect browser via WebSocket
  const browser = await puppeteer.connect({
    browserWSEndpoint: ANTIDETECT_WS,
    defaultViewport: null  // Use profile's viewport
  });

  const page = await browser.newPage();
  await page.goto('https://browserleaks.com/webgl');

  // Check that fingerprint is spoofed
  const webdriver = await page.evaluate(
    () => navigator.webdriver
  );
  console.log('navigator.webdriver:', webdriver);

  // Extract page data
  const title = await page.title();
  console.log('Page title:', title);

  // Screenshot for verification
  await page.screenshot({ path: 'fingerprint-check.png' });

  await page.close();
  // Don't close browser - antidetect manages lifecycle
}

// Multi-profile automation via antidetect API
const axios = require('axios');
const API = 'http://localhost:3001/api/v1';

async function runMultipleProfiles() {
  const { data: profiles } = await axios.get(
    `${API}/browser_profiles`
  );

  for (const profile of profiles.slice(0, 5)) {
    const { data } = await axios.get(
      `${API}/browser_profiles/${profile.id}/start`
    );

    const browser = await puppeteer.connect({
      browserWSEndpoint: data.automation.ws_endpoint,
      defaultViewport: null
    });

    const page = await browser.newPage();

    // Intercept requests for performance
    await page.setRequestInterception(true);
    page.on('request', req => {
      if (['image', 'font'].includes(req.resourceType()))
        req.abort();
      else
        req.continue();
    });

    await page.goto('https://example.com');
    console.log(`${profile.name}: ${await page.title()}`);

    await page.close();
  }
}

automateProfile();

from playwright.sync_api import sync_playwright
import requests

API_URL = "http://localhost:3001/api/v1"

def automate_with_playwright():
    with sync_playwright() as p:
        # Connect to antidetect profile via CDP
        browser = p.chromium.connect_over_cdp(
            "http://127.0.0.1:9222"
        )

        # Get the default context (with spoofed fingerprint)
        context = browser.contexts[0]
        page = context.new_page()

        page.goto("https://browserleaks.com/fonts")

        # Playwright auto-waits for elements
        title = page.title()
        print(f"Page: {title}")

        # Check fingerprint spoofing
        webdriver = page.evaluate("navigator.webdriver")
        platform = page.evaluate("navigator.platform")
        print(f"webdriver: {webdriver}, platform: {platform}")

        page.screenshot(path="antidetect-check.png")
        page.close()

# Parallel multi-profile automation
def run_parallel_profiles():
    profiles = requests.get(
        f"{API_URL}/browser_profiles"
    ).json()

    with sync_playwright() as p:
        for profile in profiles[:5]:
            # Start profile via antidetect API
            resp = requests.get(
                f"{API_URL}/browser_profiles"
                f"/{profile['id']}/start"
            ).json()

            cdp_url = resp["automation"]["cdp_url"]

            browser = p.chromium.connect_over_cdp(cdp_url)
            context = browser.contexts[0]
            page = context.new_page()

            # Route to block heavy resources
            page.route(
                "**/*.{png,jpg,gif,svg,woff,woff2}",
                lambda route: route.abort()
            )

            page.goto("https://example.com")
            print(f"{profile['name']}: {page.title()}")

            page.close()
            browser.close()

automate_with_playwright()