如何用 Selenium 绕过 CAPTCHA：常见方法

import undetected_chromedriver as uc
 
def launch_stealth_browser():
    options = uc.ChromeOptions()
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument("--window-size=1366,768")
    options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/121.0.0.0 Safari/537.36")
    
    driver = uc.Chrome(options=options)
    
    # Inject stealth scripts before any page loads
    stealth_script = """
    Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
    window.chrome = { runtime: {} };
    Object.defineProperty(navigator, 'plugins', { get: () => [1,2,3,4,5] });
    Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
    """
    driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {"source": stealth_script})
    
    # Override timezone and geolocation
    driver.execute_cdp_cmd("Emulation.setTimezoneOverride", {"timezoneId": "Europe/London"})
    driver.execute_cdp_cmd("Emulation.setGeolocationOverride", {"latitude": 51.5074, "longitude": -0.1278, "accuracy": 100})
    
    return driver
 
# Usage
driver = launch_stealth_browser()

driver.get("https://bot.sannysoft.com")

input("Check the page for automation flags, then press Enter to quit.")

driver.quit()

import json

import random

import time

from selenium.webdriver.common.by import By

from selenium.webdriver.common.keys import Keys

def save_cookies(driver, filename):

    with open(filename, "w") as f:

        json.dump(driver.get_cookies(), f)

def load_cookies(driver, filename):

    driver.get("https://example.com")  # Navigate to domain first

    with open(filename, "r") as f:

        cookies = json.load(f)

    for cookie in cookies:

        driver.add_cookie(cookie)

def human_type(element, text):

    element.click()

    # Clear field with random backspaces

    for _ in range(random.randint(2, 8)):

        element.send_keys(Keys.BACKSPACE)

        time.sleep(random.uniform(0.03, 0.1))

    for char in text:

        # 7% chance of hesitation

        if random.random() < 0.07:

            time.sleep(random.uniform(0.2, 0.6))

        element.send_keys(char)

        time.sleep(random.uniform(0.08, 0.3))

def random_wait(min_sec=1, max_sec=5):

    time.sleep(random.uniform(min_sec, max_sec))

# Example usage

driver = launch_stealth_browser()  # from previous example

driver.get("https://google.com")

random_wait(2, 4)

search_box = driver.find_element(By.NAME, "q")

human_type(search_box, "hello world")

random_wait(1, 2)

search_box.send_keys(Keys.RETURN)

# Save cookies after session

save_cookies(driver, "my_cookies.json")

driver.quit()

# Next run: load cookies

driver = launch_stealth_browser()

load_cookies(driver, "my_cookies.json")

driver.refresh()

import undetected_chromedriver as uc

import random

import time

from selenium.webdriver.common.by import By

# Proxy pool (residential proxies with auth)

PROXIES = [

    "http://user1:pass1@proxy1.example.com:8080",

    "http://user2:pass2@proxy2.example.com:8080",

]

# Simple identity profiles (just user agent and viewport for demo)

IDENTITIES = [

    {"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/121", "viewport": (1366,768)},

    {"user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605", "viewport": (1440,900)},

]

def assign_proxy_and_identity():

    proxy = random.choice(PROXIES)

    identity = random.choice(IDENTITIES)

    return proxy, identity

def launch_browser_with_proxy(proxy, identity):

    options = uc.ChromeOptions()

    options.add_argument(f"--proxy-server={proxy}")

    options.add_argument(f"--window-size={identity['viewport'][0]},{identity['viewport'][1]}")

    options.add_argument(f"--user-agent={identity['user_agent']}")

    options.add_argument("--disable-blink-features=AutomationControlled")

    return uc.Chrome(options=options)

def captcha_detected(driver):

    # Basic detection – look for keywords in page text

    body = driver.find_element(By.TAG_NAME, "body").text.lower()

    indicators = ["captcha", "verify you are human", "recaptcha"]

    return any(ind in body for ind in indicators)

# Main retry loop

MAX_RETRIES = 3

for attempt in range(MAX_RETRIES):

    proxy, identity = assign_proxy_and_identity()

    print(f"Attempt {attempt+1}: Proxy={proxy.split('@')[1]}, Identity={identity['user_agent'][:30]}...")

    driver = launch_browser_with_proxy(proxy, identity)

    driver.get("https://target-site-that-may-show-captcha.com")

    time.sleep(3)

    if captcha_detected(driver):

        print("CAPTCHA detected. Rotating proxy and identity...")

        driver.quit()

        wait_time = (attempt + 1) * 10  # exponential backoff

        print(f"Waiting {wait_time} seconds before retry.")

        time.sleep(wait_time)

        continue  # next attempt with new proxy/identity

    # No CAPTCHA – proceed with scraping

    print("No CAPTCHA. Scraping successful.")

    # ... do your work ...

    driver.quit()

    break

else:

    print("All attempts failed due to CAPTCHA.")

import time

import requests

from selenium.webdriver.common.by import By

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC

# === CONFIGURATION ===

CAPTCHA_SOLVER_API_KEY = "YOUR_API_KEY_HERE"

CAPTCHA_SOLVER_URL = "https://api.your-solver-service.com/in.php"  # Example endpoint

CAPTCHA_SOLVER_RESULT_URL = "https://api.your-solver-service.com/res.php"

# === CAPTCHA DETECTION ===

def is_captcha_present(driver):

    """Return True if a CAPTCHA iframe or text is detected."""

    try:

        # Check for common CAPTCHA elements

        if driver.find_elements(By.CSS_SELECTOR, "iframe[src*='recaptcha'], .g-recaptcha"):

            return True

        body_text = driver.find_element(By.TAG_NAME, "body").text.lower()

        indicators = ["captcha", "verify you are human", "recaptcha"]

        return any(ind in body_text for ind in indicators)

    except:

        return False

# === SOLVER INTEGRATION ===

def solve_captcha(driver):

    """

    Send the CAPTCHA challenge to a solver service and return the solution token.

    This example assumes a token‑based solver (reCAPTCHA v2/v3).

    """

    # Step 1: Extract the site key (for reCAPTCHA) – adjust selector as needed

    site_key = None

    try:

        # Look for the data-sitekey attribute on a div or iframe

        captcha_element = driver.find_element(By.CSS_SELECTOR, ".g-recaptcha")

        site_key = captcha_element.get_attribute("data-sitekey")

    except:

        # Fallback: some pages use a different structure

        try:

            iframe = driver.find_element(By.CSS_SELECTOR, "iframe[src*='recaptcha']")

            # You may need to parse the src URL to get site key, but simplified here

            pass

        except:

            pass

    if not site_key:

        raise Exception("Could not find site key for CAPTCHA")

    # Step 2: Send the challenge to the solver service

    payload = {

        "key": CAPTCHA_SOLVER_API_KEY,

        "method": "userrecaptcha",

        "googlekey": site_key,

        "pageurl": driver.current_url,

        "json": 1

    }

    response = requests.post(CAPTCHA_SOLVER_URL, data=payload)

    result = response.json()

    if result.get("status") != 1:

        raise Exception(f"Solver submission failed: {result}")

    request_id = result.get("request")

    print(f"CAPTCHA submitted, request ID: {request_id}")

    # Step 3: Poll for the solution (wait up to 60 seconds)

    for _ in range(30):  # 30 * 2 seconds = 60 seconds max

        time.sleep(2)

        poll_payload = {

            "key": CAPTCHA_SOLVER_API_KEY,

            "action": "get",

            "id": request_id,

            "json": 1

        }

        poll_resp = requests.get(CAPTCHA_SOLVER_RESULT_URL, params=poll_payload)

        poll_data = poll_resp.json()

        if poll_data.get("status") == 1:

            token = poll_data.get("request")

            print(f"CAPTCHA solved, token received: {token[:20]}...")

            return token

        elif poll_data.get("request") == "CAPCHA_NOT_READY":

            continue

        else:

            raise Exception(f"Solver error: {poll_data}")

    raise Exception("Timeout waiting for CAPTCHA solution")

# === INJECT THE SOLUTION ===

def inject_captcha_token(driver, token):

    """Inject the solution token into the page and submit."""

    # For reCAPTCHA, the token is usually injected into a hidden textarea

    try:

        driver.execute_script(f"document.getElementById('g-recaptcha-response').innerHTML = '{token}';")

    except:

        pass

    # Then submit the form (or call the callback)

    try:

        submit_button = driver.find_element(By.CSS_SELECTOR, "button[type='submit'], input[type='submit']")

        submit_button.click()

    except:

        # Some pages need to trigger the callback manually

        driver.execute_script("onSuccessCaptcha(arguments[0]);", token)

    time.sleep(3)  # wait for page to process

# === MAIN WORKFLOW WITH FALLBACK ===

def scrape_with_captcha_fallback(driver):

    """

    Perform your scraping. If a CAPTCHA appears, solve it and continue.

    """

    # ... your navigation and interaction code ...

    # After each major action, check for CAPTCHA

    if is_captcha_present(driver):

        print("CAPTCHA detected. Attempting to solve...")

        try:

            solution = solve_captcha(driver)

            inject_captcha_token(driver, solution)

            # Wait for the page to reload and re-check

            time.sleep(5)

            if is_captcha_present(driver):

                print("CAPTCHA still present after solving. Might need a retry.")

                return False

            else:

                print("CAPTCHA solved successfully. Continuing.")

        except Exception as e:

            print(f"CAPTCHA solving failed: {e}")

            return False

    # Proceed with scraping

    print("No CAPTCHA blocking – extracting data...")

    # ... your data extraction ...

    return True

# === EXAMPLE USAGE ===

if __name__ == "__main__":

    # Assume driver is already set up with stealth options

    from your_stealth_setup import launch_stealth_browser  # hypothetical import

    driver = launch_stealth_browser()

    driver.get("https://example.com/page-that-may-show-captcha")

    success = scrape_with_captcha_fallback(driver)

    if not success:

        print("Failed to bypass CAPTCHA. Consider rotating identity or proxy.")

    driver.quit()

import csv

import time

import random

from datetime import datetime

class CAPTCHAMetrics:

    def __init__(self, filename="captcha_metrics.csv"):

        self.filename = filename

        self.stats = {

            "total_requests": 0,

            "captcha_encountered": 0,

            "captcha_solved": 0,

            "captcha_failed": 0,

            "other_errors": 0

        }

        # Write header if file doesn't exist

        try:

            with open(self.filename, 'x') as f:

                writer = csv.writer(f)

                writer.writerow(["timestamp", "url", "captcha_detected", "solver_used", 

                                 "solver_success", "time_to_solve_sec", "error_message"])

        except FileExistsError:

            pass

    def log_request(self, url, captcha_detected=False, solver_used=False, 

                    solver_success=False, time_to_solve=None, error=None):

        self.stats["total_requests"] += 1

        if captcha_detected:

            self.stats["captcha_encountered"] += 1

            if solver_success:

                self.stats["captcha_solved"] += 1

            else:

                self.stats["captcha_failed"] += 1

        if error:

            self.stats["other_errors"] += 1

        with open(self.filename, 'a', newline='') as f:

            writer = csv.writer(f)

            writer.writerow([

                datetime.now().isoformat(),

                url,

                captcha_detected,

                solver_used,

                solver_success,

                time_to_solve if time_to_solve else "",

                error if error else ""

            ])

    def get_captcha_rate(self):

        if self.stats["total_requests"] == 0:

            return 0

        return (self.stats["captcha_encountered"] / self.stats["total_requests"]) * 100

    def print_summary(self):

        print("\n=== CAPTCHA Metrics Summary ===")

        print(f"Total requests: {self.stats['total_requests']}")

        print(f"CAPTCHA encountered: {self.stats['captcha_encountered']}")

        print(f"CAPTCHA solved: {self.stats['captcha_solved']}")

        print(f"CAPTCHA failed: {self.stats['captcha_failed']}")

        print(f"Other errors: {self.stats['other_errors']}")

        print(f"CAPTCHA rate: {self.get_captcha_rate():.2f}%")

        if self.stats['captcha_encountered'] > 0:

            solve_rate = (self.stats['captcha_solved'] / self.stats['captcha_encountered']) * 100

            print(f"Solve success rate: {solve_rate:.2f}%")

        print("=============================\n")