Gestione dei CAPTCHA Quando scorrere

Perché CAPTCHA Sono il più grande ostacolo del cecchino

I CAPTCHA esistono per distinguere gli esseri umani dai bot, e sono sempre più efficaci. Quando il raschiatore incontra un CAPTCHA, significa che il sito di destinazione ha rilevato un comportamento automatizzato — la frequenza di richiesta era troppo alta, il vostro IP ha bassa fiducia, o l'impronta del browser sembrava sospetto. La migliore strategia CAPTCHA è la prevenzione, non la soluzione.

Questa guida copre i tipi di CAPTCHA che si incontrano, perché la prevenzione è più efficace e più economico di risolvere, e come i proxy svolgono un ruolo critico nel evitare CAPTCHAs completamente.

Questo articolo fa parte del nostro Guida completa ai proxy Web Scraping Serie. Per la comprensione dei sistemi di rilevamento, vedere Come i sistemi anti-bot rilevano i proxy.

Tipi di CAPTCHA nel 2026

CAPTCHA invisibili Sono la vera minaccia

I CAPTCHA più pericolosi per raschiatori sono quelli che non si vedono mai. reCAPTCHA v3 e Cloudflare Turnstile eseguire in background, analizzando i movimenti del mouse, il comportamento di scorrimento, digitando i modelli e l'ambiente del browser. Assegnano un punteggio di fiducia senza mostrare alcuna sfida — e se il punteggio è troppo basso, la richiesta è silenziosamente bloccata o reindirizzata.

Prevenzione vs Risolvere: Perché vince la prevenzione

In scala, la prevenzione salva sia denaro che tempo. Risolvere 100.000 CAPTCHA al giorno costa $100-500 e aggiunge ore di latenza. Prevenire non costa niente di più oltre il corretto proxy e la gestione delle richieste.

Strategia di prevenzione 1: Utilizzare i proxy residenziali ad alta qualità

La misura unica di prevenzione CAPTCHA più efficace è l'utilizzo di proxy residenziali con alti punteggi di fiducia. Gli IP residenziali sono assegnati alle famiglie reali da parte di ISP, quindi i siti web non possono facilmente distinguere le vostre richieste dal traffico utenti autentico.

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

La piscina residenziale di ProxyHat fornisce IP da ISP reali in 190+ paesi, dando ad ogni richiesta il più alto punteggio di fiducia possibile. Vedi Residenziale vs Datacenter Proxies per Scraping per un confronto dettagliato.

Strategia di prevenzione 2: modelli di richiesta realistica

I CAPTCHA sono spesso innescati da modelli di comportamento robotico, non solo la reputazione IP. Fai sembrare il tuo raschietto umano:

Attuazione di Python

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

Node.js Attuazione

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 di prevenzione 3: Rotazione IP intelligente

Il modo in cui si ruotano gli IP influisce direttamente sulle tariffe CAPTCHA. La rotazione aggressiva (nuovo IP ogni richiesta) può effettivamente aumentare CAPTCHAs su alcuni siti, perché una serie di richieste da diversi IP che accede allo stesso percorso di sessione sembra sospetto.

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

Per più modelli di rotazione, vedere Strategie di rotazione proxy per Scraping a grande scala.

Strategia di prevenzione 4: Limiti di tasso di rispetto

I CAPTCHA sono spesso l'escalation dopo la limitazione dei tassi. Se si gestisce correttamente i segnali limite di tasso, raramente si vede CAPTCHAs:

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

Per strategie complete di limite di tasso, vedere Limiti di velocità di scorrimento spiegati.

Quando è necessario gestire CAPTCHAs: rilevamento e routine

Anche con una prevenzione perfetta, alcuni CAPTCHA sono inevitabili. Costruire il rilevamento nella pipeline in modo da poter indirizzare pagine CAPTCHA per una gestione speciale:

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

CAPTCHA Prevenzione Checklist

• Utilizzare i proxy residenziali. Hanno i più alti punteggi di fiducia e innescare i più pochi CAPTCHA. Prossi residenziali ProxyHat fornire milioni di IP puliti.
• Impostare intestazioni realistiche. Sempre inviare User-Agent, accettare, accettare-language e altre intestazioni del browser standard.
• Aggiungete ritardi simili all'uomo. Ragione 1-5 secondi ritardi tra richieste con pause occasionali più lunghe.
• Mantenere le sessioni correttamente. Utilizzare cookie e IP coerenti per le relative richieste tramite sessioni appiccicose.
• Rispetta robots.txt. Siti che rilevano robots.txt violazioni escalate a CAPTCHAs più velocemente.
• Monitorare i tassi CAPTCHA. Se il tasso CAPTCHA supera il 5%, qualcosa nel vostro approccio ha bisogno di fissaggio.
• Evitare di raschiare durante le ore di punta. I sistemi anti-bot sono più aggressivi durante periodi ad alto traffico.
• Ruotare correttamente gli utenti. Utilizza stringhe di browser recenti e realistiche. Non mescolare UAs mobile e desktop sulla stessa sessione.

Per configurare il proxy nella tua lingua preferita, vedere Utilizzo di Proxies in Python♪ Utilizzo di Proxies in Node.jso Utilizzo dei proxy in Go. Esplorare ProxyHat per Scraping Web per iniziare.

Domande frequenti

I proxy possono aiutare ad evitare CAPTCHA?

Si', in modo significativo. I proxy residenziali di alta qualità hanno una reputazione IP pulita che raramente innescano CAPTCHA. Gli IP del datacenter sono contrassegnati più spesso perché sono noti fonti automatizzate. La combinazione di proxy residenziali con modelli di richiesta appropriati elimina virtualmente CAPTCHAs per la maggior parte degli obiettivi.

Qual è il modo più economico per gestire CAPTCHA in scala?

Prevenzione. Investire in proxy residenziali e modelli di demolizione adeguati costa molto meno di CAPTCHA servizi di risoluzione in scala. Se è necessario risolvere CAPTCHA, i servizi di terze parti costano $1-3 per 1.000, ma aggiungere 1060 secondi di latenza per richiesta.

I browser senza testa aiutano con CAPTCHAs?

Aiutano con CAPTCHA invisibili (reCAPTCHA v3, Turnstile) fornendo un vero ambiente browser con esecuzione JavaScript. Tuttavia, sono più lenti e più resistenti alle risorse. Utilizzarli solo per gli obiettivi che specificatamente richiedono la verifica del livello del browser.

Come faccio a sapere se sto ottenendo pagine CAPTCHA?

Controllare la risposta HTML per gli indicatori CAPTCHA: "captcha", "recaptcha", "hcaptcha", "challenge", o "verificare sei umano". Anche guardare per risposte inaspettate 403 e reindirizza a sfida URL. Costruire il rilevamento automatico nella vostra pipeline di raschiamento.

Perché ho ancora CAPTCHA con proxy residenziali?

Di solito a causa di modelli di richiesta, non la qualità IP. Cause comuni: troppe richieste al minuto, intestazioni del browser mancanti, problemi di gestione dei cookie, o modelli di demolizione troppo sistematici. Rallentare, aggiungere jitter e utilizzare sessioni appiccicose per richieste correlate.