Obsługa CAPTCHA Podczas skracania

Dlaczego CAPTCHA Czy Największe Przeszkody Scrapera

CAPTCHA istnieją, aby odróżnić ludzi od botów, i są one coraz bardziej skuteczne w tym. Kiedy Twój scraper napotyka CAPTCHA, oznacza to, że strona docelowa wykryła automatyczne zachowanie - częstotliwość żądania była zbyt wysoka, Twój IP ma niskie zaufanie, lub Twój odcisk palca przeglądarki wyglądał podejrzanie. Najlepszą strategią CAPTCHA jest zapobieganie, a nie rozwiązywanie.

Przewodnik ten obejmuje rodzaje CAPTCHA, które spotkasz, dlaczego zapobieganie jest bardziej skuteczne i tańsze niż rozwiązanie, i jak proxy odgrywają kluczową rolę w unikaniu CAPTCHA całkowicie.

Ten artykuł jest częścią naszego Kompletny przewodnik do Web Scraping Proxies Seria. Aby zrozumieć systemy wykrywania, zobacz Jak systemy Anti- Bot wykrywają efekty.

Typy CAPTCHA w 2026 r.

Niewidzialne CAPTCHA Czy prawdziwe zagrożenie

Najbardziej niebezpieczne CAPTCHA dla drapaczy są te, których nigdy nie widać. reCAPTCHA v3 oraz Chmura Turnstille działa w tle, analizując ruchy myszy, przewijanie zachowania, wzorce pisania i środowiska przeglądarki. Przydzielają one wynik zaufania nie pokazując żadnych wyzwań - a jeśli wynik jest zbyt niski, wniosek jest po cichu zablokowany lub przekierowany.

Zapobieganie a rozwiązywanie problemów: Dlaczego zapobieganie wygrywa

W skali, zapobieganie oszczędza zarówno pieniądze i czas. Rozwiązanie 100.000 CAPTCHA dziennie kosztuje $100- 500 i dodaje godziny opóźnienia. Zapobieganie im nie kosztuje nic więcej, poza odpowiednim zastępstwem i zarządzaniem żądaniami.

Strategia zapobiegania 1: Korzystanie z wysokiej jakości profili mieszkalnych

Jednym z najskuteczniejszych środków prewencyjnych CAPTCHA jest stosowanie proxy mieszkaniowych z wysoką ocenę zaufania. Lokalne IP są przypisywane do rzeczywistych gospodarstw domowych przez dostawców usług internetowych, więc strony internetowe nie mogą łatwo odróżnić Twoich żądań od prawdziwego ruchu użytkowników.

import requests
# Residential proxy — high trust score, fewer CAPTCHAs
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def scrape_with_residential(url: str) -> str:
    """Use residential proxies to avoid triggering CAPTCHAs."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/120.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
    })
    resp = session.get(url, timeout=30)
    return resp.text

Basen mieszkalny ProxyHat zapewnia IP z prawdziwych dostawców usług internetowych w 190 + państwa, dając każdej prośbie najwyższy możliwy wynik zaufania. Patrz Residential vs Datacenter Proxies for Scraping Szczegółowe porównanie.

Strategia zapobiegania 2: Wzory realistycznych wniosków

CAPTCHA są często wywoływane przez robotyczne wzorce zachowania, nie tylko reputacja IP. Spraw, żeby twój skrobacz wyglądał jak człowiek:

Wdrażanie Pythona

import requests
import random
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15",
]
REFERRERS = [
    "https://www.google.com/",
    "https://www.bing.com/",
    "https://duckduckgo.com/",
    None,  # Direct visit
]
def human_like_scrape(urls: list[str]) -> list[str]:
    """Scrape with realistic human behavior patterns."""
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    for url in urls:
        # Randomize headers per request
        headers = {
            "User-Agent": random.choice(USER_AGENTS),
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
            "Upgrade-Insecure-Requests": "1",
        }
        referrer = random.choice(REFERRERS)
        if referrer:
            headers["Referer"] = referrer
        try:
            resp = session.get(url, headers=headers, timeout=30)
            results.append(resp.text)
        except requests.RequestException:
            results.append(None)
        # Human-like delays: 1-5 seconds with occasional longer pauses
        if random.random() < 0.1:
            time.sleep(random.uniform(5, 15))  # 10% chance of long pause
        else:
            time.sleep(random.uniform(1, 4))
    return results

Wdrażanie Node.js

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
const USER_AGENTS = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
];
function randomDelay() {
  const isLongPause = Math.random() < 0.1;
  const ms = isLongPause
    ? 5000 + Math.random() * 10000
    : 1000 + Math.random() * 3000;
  return new Promise(r => setTimeout(r, ms));
}
async function humanLikeScrape(urls) {
  const results = [];
  for (const url of urls) {
    const headers = {
      'User-Agent': USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
      'Accept-Language': 'en-US,en;q=0.9',
    };
    try {
      const res = await fetch(url, { agent, headers, timeout: 30000 });
      results.push(await res.text());
    } catch {
      results.push(null);
    }
    await randomDelay();
  }
  return results;
}

Strategia zapobiegania 3: Inteligentna rotacja IP

Sposób, w jaki obracasz IP wpływa bezpośrednio na stawki CAPTCHA. Agresywna rotacja (nowe IP każdy wniosek) może rzeczywiście zwiększyć CAPTCHA na niektórych stronach, ponieważ seria wniosków różnych IP dostępu do tej samej ścieżki sesji wygląda podejrzanie.

import requests
import uuid
def create_session_for_site(site_id: str):
    """Create a sticky session that maintains the same IP per site.
    This avoids the suspicious pattern of different IPs accessing the same flow."""
    session_id = uuid.uuid5(uuid.NAMESPACE_URL, site_id).hex[:8]
    proxy = f"http://USERNAME-session-{session_id}:PASSWORD@gate.proxyhat.com:8080"
    session = requests.Session()
    session.proxies = {"http": proxy, "https": proxy}
    return session
# Same IP for all requests to a specific product section
session = create_session_for_site("example.com-electronics")
page1 = session.get("https://example.com/electronics?page=1")
page2 = session.get("https://example.com/electronics?page=2")
page3 = session.get("https://example.com/electronics?page=3")
# Different IP for a different section
session2 = create_session_for_site("example.com-clothing")
clothes1 = session2.get("https://example.com/clothing?page=1")

Więcej wzorów rotacji, zobacz Strategie rotacji proxy dla rozdrabniania na dużą skalę.

Strategia zapobiegania 4: Granice stawek szacunku

CAPTCHA są często eskalacja po ograniczenie stawki. Jeśli poprawnie obsługujesz sygnały graniczne prędkości, rzadko widzisz CAPTCHA:

import requests
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
CAPTCHA_INDICATORS = [
    "captcha",
    "recaptcha",
    "hcaptcha",
    "challenge",
    "verify you are human",
    "please complete the security check",
]
def is_captcha_page(html: str) -> bool:
    """Detect if the response is a CAPTCHA challenge page."""
    html_lower = html.lower()
    return any(indicator in html_lower for indicator in CAPTCHA_INDICATORS)
def scrape_with_captcha_detection(urls: list[str]) -> list[dict]:
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    captcha_count = 0
    backoff = 2.0
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            if resp.status_code == 200 and not is_captcha_page(resp.text):
                results.append({"url": url, "status": "success", "body": resp.text})
                captcha_count = 0
                backoff = max(backoff * 0.9, 1.0)  # Reduce backoff on success
            elif is_captcha_page(resp.text) or resp.status_code == 403:
                captcha_count += 1
                results.append({"url": url, "status": "captcha"})
                if captcha_count >= 3:
                    # Too many CAPTCHAs — increase backoff significantly
                    backoff = min(backoff * 3, 60)
                    print(f"CAPTCHA streak: {captcha_count}. Backing off to {backoff:.0f}s")
                else:
                    backoff = min(backoff * 1.5, 30)
        except requests.RequestException as e:
            results.append({"url": url, "status": "error", "error": str(e)})
        time.sleep(backoff)
    return results

W przypadku kompleksowych strategii ograniczania stóp procentowych, patrz: Rozdrapywanie wartości granicznych.

When You Must Handle CAPTCHA: Detection and Routing

Nawet z doskonałą profilaktyką, niektóre CAPTCHA są nieuniknione. Zbuduj wykrywanie do swojego rurociągu, dzięki czemu możesz przekierować strony CAPTCHA do specjalnej obsługi:

import requests
from enum import Enum
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
class ResponseType(Enum):
    SUCCESS = "success"
    CAPTCHA = "captcha"
    BLOCKED = "blocked"
    ERROR = "error"
def classify_response(resp: requests.Response) -> ResponseType:
    """Classify a response to determine next action."""
    if resp.status_code == 403:
        return ResponseType.BLOCKED
    if resp.status_code == 429:
        return ResponseType.BLOCKED
    if resp.status_code == 200:
        html = resp.text.lower()
        captcha_signals = ["captcha", "recaptcha", "hcaptcha", "cf-challenge"]
        if any(s in html for s in captcha_signals):
            return ResponseType.CAPTCHA
        return ResponseType.SUCCESS
    return ResponseType.ERROR
def scrape_with_routing(urls: list[str]) -> dict:
    """Scrape URLs and route based on response classification."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    results = {"success": [], "captcha": [], "blocked": [], "error": []}
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            response_type = classify_response(resp)
            results[response_type.value].append(url)
            if response_type == ResponseType.CAPTCHA:
                # Route to CAPTCHA queue for manual or service-based solving
                print(f"CAPTCHA detected: {url}")
            elif response_type == ResponseType.BLOCKED:
                # Rotate IP and retry
                print(f"Blocked: {url}")
        except requests.RequestException:
            results["error"].append(url)
    print(f"Success: {len(results['success'])}, "
          f"CAPTCHAs: {len(results['captcha'])}, "
          f"Blocked: {len(results['blocked'])}")
    return results

Lista kontrolna prewencji CAPTCHA

• Użyj proxy mieszkalnych. Mają najwyższe wyniki i uruchamiają najmniejsze CAPTCHA. ProxyHat proxy mieszkalne zapewnić miliony czystych IP.
• Ustaw realistyczne nagłówki. Zawsze wyślij User- Agent, Akceptuj, Akcept- Język i inne standardowe nagłówki przeglądarki.
• Dodać opóźnienia podobne do ludzkich. Losowe 1-5 sekund opóźnienia pomiędzy wnioskami z sporadycznie dłuższych przerw.
• Utrzymać sesje prawidłowo. Użyj plików cookie i spójnych IP dla związanych z nimi żądań poprzez lepkie sesje.
• Szacunek robot.txt. Witryny, które wykrywają bobots.txt naruszenia eskalują do CAPTCHA szybciej.
• Monitoruj wskaźniki CAPTCHA. Jeśli wskaźnik CAPTCHA przekracza 5%, coś w podejściu wymaga naprawy.
• Unikać drapania w godzinach szczytu. Systemy antybotowe są bardziej agresywne w okresach dużego ruchu.
• Obróć agentów User- prawidłowo. Użyj ostatnich, realistycznych strun przeglądarki. Nie mieszać UA mobilne i stacjonarne w tej samej sesji.

Ustawienie proxy w preferowanym języku, zobacz Korzystanie z proxies w Python, Korzystanie z Proxies w Node.jslub Korzystanie z proxies in GoZbadaj ProxyHat do skracania stron internetowych Na początek.

Często zadawane pytania

Czy proxy mogą pomóc uniknąć CAPTCHA?

Tak, znacznie. Wysokiej jakości proxy mieszkaniowe mają czyste reputacje IP, które rzadko uruchamiają CAPTCHA. IPs Datacenter są oznaczone częściej, ponieważ są znane źródła automatyczne. Połączenie proxy mieszkalnych z odpowiednimi wzorami żądania praktycznie eliminuje CAPTCHA dla większości celów.

Jaki jest najtańszy sposób obsługi CAPTCHA w skali?

Zapobieganie. Inwestowanie w proxy mieszkaniowe i właściwe wzorce skrobania kosztuje znacznie mniej niż usługi rozwiązywania CAPTCHA na skalę. Jeśli musisz rozwiązać CAPTCHA, usługi trzeciej strony kosztuje 1-3 dolarów za 1000, ale dodać 10- 60 sekund opóźnienia na życzenie.

Czy przeglądarki bez głowy pomagają przy CAPTCHA?

Pomagają one w niewidzialnym CAPTCHA (reCAPTCHA v3, Turnstile) poprzez zapewnienie prawdziwego środowiska przeglądarki z JavaScript wykonywania. Są jednak wolniejsze i bardziej zasobochłonne. Użyj ich tylko do celów, które w szczególności wymagają weryfikacji na poziomie przeglądarki.

Skąd mam wiedzieć, czy dostaję strony CAPTCHA?

Sprawdź odpowiedzi HTML dla wskaźników CAPTCHA: "captcha", "recaptcha", "hcaptcha", "challenge", lub "confirme you are human". Obserwuj również nieoczekiwane odpowiedzi 403 i przekierowanie do kwestionowania adresów URL. Zbuduj zautomatyzowaną detekcję do swojego rurociągu.

Dlaczego nadal mam CAPTCHA z proxy mieszkaniowe?

Zazwyczaj z powodu wzorców żądań, nie jakości IP. Powszechne przyczyny: zbyt wiele żądań na minutę, brakujące nagłówki przeglądarki, problemy z obsługą plików cookie lub zbyt systematyczne zeskrobywanie. Zwolnij, dodaj jitter i używaj lepkich sesji dla odpowiednich żądań.