Bypass Turnstile e hCaptcha: tecnologie di protezione e metodi di soluzione

Cloudflare Turnstile e hCaptcha sono diventati lo standard di protezione dei servizi web contro i bot, sostituendo la tradizionale reCAPTCHA. Questi sistemi analizzano decine di parametri del browser e dell'ambiente di rete, rendendo l'uso di proxy una sfida seria per l'automazione. In questo articolo esploreremo come funzionano queste tecnologie a livello tecnico e quali metodi di bypass sono realmente efficaci quando si lavora tramite proxy.

Come funziona Cloudflare Turnstile

Cloudflare Turnstile è un sistema di protezione di nuova generazione, posizionato come "alternativa invisibile alla CAPTCHA". A differenza della classica reCAPTCHA, Turnstile non richiede all'utente di selezionare semafori o attraversamenti pedonali. Invece, il sistema analizza le caratteristiche comportamentali e tecniche del browser in background.

Tecnologicamente, Turnstile funziona in tre fasi. La prima è il caricamento del widget JavaScript, che viene inserito nella pagina tramite iframe. La seconda è la raccolta della telemetria: il sistema raccoglie dati sul browser, inclusi WebGL fingerprint, Canvas fingerprint, elenco dei font, risoluzione dello schermo, fuso orario, lingua del sistema e molti altri parametri. La terza fase è la validazione sui server Cloudflare, dove i dati raccolti vengono confrontati con modelli noti di bot e proxy.

Una caratteristica chiave di Turnstile è l'uso di un sistema di reputazione degli indirizzi IP. Cloudflare possiede un'enorme base di dati, raccolta da milioni di siti che utilizzano il loro CDN e protezione DDoS. Se un indirizzo IP viene notato in attività sospette, la probabilità di superare Turnstile diminuisce drasticamente. Questo crea il primo problema per gli utenti proxy: anche gli IP residenziali puliti possono avere una bassa reputazione a causa dei precedenti proprietari.

Tecnologia hCaptcha e metodi di rilevamento

hCaptcha è emersa come concorrente di Google reCAPTCHA, con un focus sulla privacy e monetizzazione tramite machine learning. Il sistema offre ai proprietari di siti la possibilità di pagare per l'uso dei dati degli utenti per addestrare modelli AI. Dal punto di vista tecnico, hCaptcha è più aggressivo nel rilevamento dell'automazione rispetto a Turnstile.

Il meccanismo principale di funzionamento di hCaptcha include diversi livelli di protezione. Il primo livello è il controllo dei parametri di rete: il sistema analizza il TTL dei pacchetti, i ritardi nella rete, la coerenza della geolocalizzazione dell'indirizzo IP e il fuso orario dichiarato del browser. Il secondo livello è le chiamate JavaScript: hCaptcha verifica la presenza e il corretto funzionamento delle API Web, inclusi WebRTC, Battery API, Sensor API. Il terzo livello è l'analisi comportamentale dei movimenti del mouse, della velocità di scorrimento e dei modelli di clic.

Una caratteristica di hCaptcha è l'uso di controlli basati su sfide. Se il sistema sospetta un bot, mostra compiti visivi: selezione di immagini con oggetti specifici, risoluzione di enigmi, riconoscimento di testo su immagini distorte. La difficoltà dei compiti aumenta dinamicamente ad ogni tentativo fallito. Per gli utenti proxy, questo significa che anche con un fingerprint corretto si può ottenere una catena infinita di captcha.

Browser fingerprinting e proxy

Il browser fingerprinting è una tecnica di identificazione dell'utente basata su un insieme unico di caratteristiche del browser e del dispositivo. Anche se utilizzi un proxy per cambiare l'indirizzo IP, il fingerprint rimane invariato e può rivelare l'uso dell'automazione. I moderni sistemi di protezione raccolgono da 50 a oltre 200 parametri per creare un'impronta.

I componenti principali del fingerprint includono: Canvas fingerprint (rendering grafico unico, dipendente da GPU e driver), WebGL fingerprint (parametri dell'acceleratore grafico), Audio Context fingerprint (caratteristiche dell'elaborazione audio), elenco dei font installati, parametri dello schermo (risoluzione, profondità colore, pixel ratio), User-Agent e intestazioni del browser, impostazioni linguistiche, fuso orario, presenza di plugin ed estensioni.

Il problema per gli utenti proxy risiede nelle incongruenze. Ad esempio, se il tuo indirizzo IP mostra una posizione in Germania, ma il fuso orario del browser è impostato su Mosca, questo è un segnale di allerta. Se una perdita WebRTC rivela il tuo vero indirizzo IP, diverso da quello del proxy, il sistema identificherà immediatamente la sostituzione. Se l'User-Agent dichiara Windows, ma il Canvas fingerprint corrisponde a Linux, il rilevamento è garantito.

// Esempio di raccolta del fingerprint di base
const fingerprint = {
  canvas: getCanvasFingerprint(),
  webgl: getWebGLFingerprint(),
  fonts: getFonts(),
  screen: {
    width: screen.width,
    height: screen.height,
    colorDepth: screen.colorDepth,
    pixelRatio: window.devicePixelRatio
  },
  timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  language: navigator.language,
  platform: navigator.platform,
  hardwareConcurrency: navigator.hardwareConcurrency,
  deviceMemory: navigator.deviceMemory,
  webrtc: await getWebRTCIPs()
};

function getCanvasFingerprint() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.textBaseline = 'top';
  ctx.font = '14px Arial';
  ctx.fillText('Browser fingerprint', 2, 2);
  return canvas.toDataURL();
}

Metodi di rilevamento dei server proxy

I sistemi di protezione utilizzano molte tecniche per rilevare i proxy. Il primo metodo è il controllo delle banche dati di proxy e VPN noti. Servizi come IPHub, IP2Proxy, MaxMind GeoIP2 contengono milioni di indirizzi IP classificati come proxy, VPN, provider di hosting. Cloudflare e hCaptcha sono integrati con tali banche dati e aumentano automaticamente il livello di verifica per gli IP sospetti.

Il secondo metodo è l'analisi ASN (Autonomous System Number). I proxy di data center appartengono solitamente a provider di hosting (AWS, DigitalOcean, OVH), il che è facilmente identificabile tramite ASN. I proxy residenziali utilizzano ASN di normali provider di servizi Internet (Comcast, Verizon, Deutsche Telekom), rendendoli meno sospetti. Tuttavia, anche le reti residenziali possono essere parzialmente compromesse se il provider è noto per la vendita di proxy.

Il terzo metodo è l'analisi comportamentale a livello di rete. I sistemi monitorano anomalie: TTL dei pacchetti troppo basso o troppo alto, ritardi non caratteristici, utilizzo di porte non standard, incongruenze nella geolocalizzazione e nel percorso di routing. Ad esempio, se un indirizzo IP è geolocalizzato negli Stati Uniti, ma il traceroute mostra un percorso attraverso server europei, questo è un segnale di proxy.

Proxy residenziali come soluzione di base

I proxy residenziali sono fondamentali per bypassare Turnstile e hCaptcha. A differenza dei proxy di data center, i proxy residenziali utilizzano indirizzi IP di dispositivi reali: router domestici, telefoni cellulari, dispositivi IoT. Questo li rende praticamente indistinguibili dagli utenti normali dal punto di vista dell'infrastruttura di rete.

I principali vantaggi dei proxy residenziali per bypassare le captcha: appartenenza a ISP (Internet Service Provider), e non a provider di hosting; reputazione pulita degli indirizzi IP nella maggior parte dei casi; geolocalizzazione e routing corretti; bassa probabilità di finire nelle liste nere. Tuttavia, non tutti i proxy residenziali sono ugualmente efficaci. Diversi fattori sono critici.

Il primo fattore è la rotazione degli indirizzi IP. I proxy residenziali statici (sticky sessions) consentono di utilizzare un IP da pochi minuti a diverse ore. Questo è ottimale per scenari in cui è necessario mantenere una sessione: autorizzazione, compilazione di moduli, operazioni a più fasi. I proxy rotazionali cambiano IP ad ogni richiesta o secondo un timer, il che è utile per il parsing, ma può causare problemi con le captcha a causa del frequente cambio di contesto.

Il secondo fattore è la distribuzione geografica. Per bypassare le captcha è importante che la geolocalizzazione dell'IP corrisponda al targeting del sito e alle impostazioni del browser. Se lavori con un sito tedesco, utilizza proxy residenziali tedeschi e imposta il fuso orario appropriato (Europe/Berlin), la lingua (de-DE) e la località nel browser.

Il terzo fattore è la qualità del provider di proxy. I proxy residenziali economici sono spesso raccolti tramite metodi discutibili (app di VPN gratuite, dispositivi infetti), il che porta a una bassa reputazione del pool di IP. I provider professionali lavorano con partnership SDK legittime e monitorano attentamente la qualità della rete. Controlla il tasso di successo del provider sui siti target prima di scalare.

Strumenti di automazione: Selenium, Puppeteer, Playwright

La scelta dello strumento di automazione influisce criticamente sulla capacità di bypassare le captcha. Selenium, Puppeteer e Playwright sono tre soluzioni principali, ognuna con le proprie caratteristiche di rilevamento. I sistemi di protezione sono in grado di determinare l'uso di questi strumenti attraverso decine di segnali.

Selenium è lo strumento più vecchio e più facilmente rilevabile. Un browser controllato da Selenium ha marcatori evidenti: la variabile window.navigator.webdriver è impostata su true, mancano alcune proprietà dell'oggetto navigator, dimensioni della finestra del browser caratteristiche dell'automazione. Anche con un proxy, Selenium spesso fallisce i controlli di Turnstile e hCaptcha senza ulteriore offuscamento.

Puppeteer e Playwright sono strumenti più moderni basati sul Chrome DevTools Protocol. Vengono anch'essi rilevati, ma presentano meno segnali evidenti. I principali metodi di rilevamento includono: controllo di chrome.runtime, analisi delle API delle autorizzazioni, rilevamento della modalità headless tramite assenza di plugin e dimensioni specifiche del viewport, verifica della presenza di DevTools tramite attacchi di timing.

// Configurazione di base di Puppeteer con proxy e anti-detect
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
  headless: false, // headless: true è facilmente rilevabile
  args: [
    '--proxy-server=http://your-proxy:port',
    '--disable-blink-features=AutomationControlled',
    '--disable-dev-shm-usage',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-web-security',
    '--disable-features=IsolateOrigins,site-per-process',
    `--window-size=1920,1080`,
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const page = await browser.newPage();

// Autenticazione del proxy
await page.authenticate({
  username: 'proxy_user',
  password: 'proxy_pass'
});

// Ridefinizione della proprietà webdriver
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => false
  });
  
  // Emulazione dei plugin per headless
  Object.defineProperty(navigator, 'plugins', {
    get: () => [1, 2, 3, 4, 5]
  });
});

Per un serio bypass delle captcha, si raccomanda di utilizzare browser anti-detect specializzati: Multilogin, GoLogin, AdsPower, Dolphin Anty. Queste soluzioni creano profili browser isolati con fingerprint unici, gestiscono cookie e session storage, sincronizzano automaticamente il fuso orario con la geolocalizzazione del proxy, emulano fingerprint Canvas e WebGL realistici.

Servizi di risoluzione captcha: integrazione ed efficacia

Quando i metodi tecnici non sono sufficienti, entrano in gioco i servizi di risoluzione captcha. Questi si dividono in due tipi: umani (crowdsourcing) e automatici (machine learning). Per Turnstile e hCaptcha, l'efficacia varia.

I servizi umani (2Captcha, AntiCaptcha, CapSolver, CapMonster Cloud) funzionano secondo il principio del lavoro distribuito: la tua captcha viene inviata a una persona reale, che la risolve manualmente. Vantaggi: alto tasso di successo (95-99% per hCaptcha, 85-95% per Turnstile), supporto per compiti visivi complessi, stabilità relativa. Svantaggi: velocità di risoluzione di 10-60 secondi, costo di $1-3 per 1000 captcha, dipendenza dalla disponibilità degli operatori.

I servizi automatici utilizzano modelli AI per il riconoscimento. Sono più veloci (1-5 secondi) e più economici, ma hanno un tasso di successo inferiore per le captcha moderne — di solito 60-80% per hCaptcha e 50-70% per Turnstile. Sono efficaci per compiti semplici basati su sfide, ma spesso falliscono nei controlli invisibili.

// Integrazione di 2Captcha per risolvere hCaptcha
const axios = require('axios');

async function solveHCaptcha(sitekey, pageUrl, proxyConfig) {
  const API_KEY = 'your_2captcha_api_key';
  
  // Invio del compito
  const createTask = await axios.post('https://2captcha.com/in.php', null, {
    params: {
      key: API_KEY,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      proxy: `${proxyConfig.type}:${proxyConfig.host}:${proxyConfig.port}:${proxyConfig.user}:${proxyConfig.pass}`,
      json: 1
    }
  });
  
  const taskId = createTask.data.request;
  
  // Attesa della risoluzione
  let solution = null;
  for (let i = 0; i < 60; i++) {
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    const result = await axios.get('https://2captcha.com/res.php', {
      params: {
        key: API_KEY,
        action: 'get',
        id: taskId,
        json: 1
      }
    });
    
    if (result.data.status === 1) {
      solution = result.data.request;
      break;
    }
  }
  
  return solution; // token da inserire nel modulo
}

// Utilizzo in Puppeteer
const captchaToken = await solveHCaptcha(
  'site-key-from-page',
  'https://example.com',
  { type: 'http', host: 'proxy.example.com', port: 8080, user: 'user', pass: 'pass' }
);

await page.evaluate((token) => {
  document.querySelector('[name="h-captcha-response"]').value = token;
  document.querySelector('[name="g-recaptcha-response"]').value = token;
}, captchaToken);

È fondamentale fornire i parametri proxy corretti al servizio di risoluzione captcha. Se la captcha viene risolta da un IP e poi il token viene utilizzato da un altro, la validazione fallirà. Le captcha moderne legano il token all'indirizzo IP, all'User-Agent e ad altri parametri di sessione.

Tecniche avanzate: emulazione dei dispositivi e TLS fingerprinting

Per bypassare i sistemi più protetti sono necessarie tecniche avanzate che vanno oltre la configurazione di base di proxy e browser. Due aree chiave sono l'emulazione dei dispositivi mobili e la gestione del TLS fingerprint.

I proxy mobili combinati con l'emulazione dei browser mobili offrono un'elevata efficacia contro le captcha. Le ragioni: il traffico mobile ha un punteggio di fiducia più alto, gli indirizzi IP mobili (soprattutto 4G/5G) sono spesso dinamici e cambiano in modo naturale, i dispositivi mobili hanno un diverso insieme di parametri di fingerprint, molti siti semplificano i controlli per gli utenti mobili.

Per un'emulazione corretta di un dispositivo mobile è necessario: utilizzare un User-Agent mobile (corrispondenza esatta con il modello del dispositivo), impostare il viewport e il devicePixelRatio corretti, emulare eventi touch invece di eventi mouse, utilizzare valori mobili per navigator.platform e navigator.maxTouchPoints, configurare il WebGL e il Canvas fingerprint per un modello specifico di dispositivo.

// Emulazione di iPhone 13 Pro in Playwright
const { chromium, devices } = require('playwright');

const iPhone13Pro = devices['iPhone 13 Pro'];

const browser = await chromium.launch({
  proxy: {
    server: 'http://mobile-proxy:port',
    username: 'user',
    password: 'pass'
  }
});

const context = await browser.newContext({
  ...iPhone13Pro,
  locale: 'en-US',
  timezoneId: 'America/New_York',
  geolocation: { latitude: 40.7128, longitude: -74.0060 },
  permissions: ['geolocation']
});

const page = await context.newPage();

// Configurazione aggiuntiva del fingerprint
await page.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', {
    get: () => 6 // iPhone 13 Pro ha 6 core
  });
  
  Object.defineProperty(navigator, 'deviceMemory', {
    get: () => 6 // 6GB RAM
  });
});

Il TLS fingerprinting è un metodo di identificazione del cliente basato sui parametri della connessione TLS/SSL. Ogni browser e sistema operativo ha una combinazione unica di cipher suites, extensions, elliptic curves, che vengono trasmesse durante l'instaurazione di una connessione HTTPS. I sistemi di protezione analizzano il TLS fingerprint e lo confrontano con l'User-Agent dichiarato.

Il problema degli strumenti di automazione standard è che utilizzano il TLS fingerprint di base di Chromium, che differisce da Chrome completo. Questa incongruenza viene rilevata. Soluzioni: utilizzo di librerie come curl-impersonate o tls-client per Python, che emulano il TLS fingerprint di browser specifici; applicazione di client HTTP con personalizzazione TLS (ad esempio, cycletls per Node.js); utilizzo di browser completi invece di modalità headless.

Esempi pratici di codice

Consideriamo un esempio completo di bypass di Turnstile utilizzando Playwright, proxy residenziali e tecniche anti-detect. Questo codice dimostra un approccio complessivo alla risoluzione del problema.

const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

// Configurazione del proxy
const proxyConfig = {
  server: 'http://residential-proxy.proxycove.com:8080',
  username: 'your_username',
  password: 'your_password'
};

// Impostazioni per l'emulazione di un utente reale dalla Germania
const userConfig = {
  viewport: { width: 1920, height: 1080 },
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  locale: 'de-DE',
  timezoneId: 'Europe/Berlin',
  geolocation: { latitude: 52.5200, longitude: 13.4050 }, // Berlino
  permissions: ['geolocation']
};

async function bypassTurnstile(url) {
  const browser = await chromium.launch({
    headless: false, // importante per captcha complesse
    proxy: proxyConfig,
    args: [
      '--disable-blink-features=AutomationControlled',
      '--no-sandbox',
      '--disable-dev-shm-usage'
    ]
  });

  const context = await browser.newContext({
    ...userConfig,
    // Intestazioni aggiuntive
    extraHTTPHeaders: {
      'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
      'Accept-Encoding': 'gzip, deflate, br',
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
      'DNT': '1',
      'Connection': 'keep-alive',
      'Upgrade-Insecure-Requests': '1'
    }
  });

  const page = await context.newPage();

  // Iniezione di script anti-detect
  await page.addInitScript(() => {
    // Nascondere il webdriver
    Object.defineProperty(navigator, 'webdriver', {
      get: () => undefined
    });

    // Emulazione del runtime di chrome
    window.chrome = {
      runtime: {}
    };

    // Ridefinizione delle autorizzazioni
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
      parameters.name === 'notifications' ?
        Promise.resolve({ state: Notification.permission }) :
        originalQuery(parameters)
    );

    // Valori più realistici per Windows
    Object.defineProperty(navigator, 'platform', {
      get: () => 'Win32'
    });

    Object.defineProperty(navigator, 'hardwareConcurrency', {
      get: () => 8
    });

    Object.defineProperty(navigator, 'deviceMemory', {
      get: () => 8
    });
  });

  // Emulazione del comportamento umano
  async function humanLikeDelay(min = 1000, max = 3000) {
    const delay = Math.random() * (max - min) + min;
    await page.waitForTimeout(delay);
  }

  async function humanLikeMouseMove() {
    const viewportSize = page.viewportSize();
    const x = Math.random() * viewportSize.width;
    const y = Math.random() * viewportSize.height;
    await page.mouse.move(x, y, { steps: 10 });
  }

  try {
    // Navigazione alla pagina
    await page.goto(url, { waitUntil: 'networkidle' });
    
    await humanLikeDelay(2000, 4000);
    await humanLikeMouseMove();

    // Attesa del caricamento di Turnstile
    await page.waitForSelector('iframe[src*="turnstile"]', { timeout: 10000 });
    
    console.log('Turnstile rilevato, attesa della risoluzione automatica...');
    
    // Turnstile in modalità managed viene spesso risolto automaticamente
    // Aspettiamo l'apparizione del token
    await page.waitForFunction(() => {
      const response = document.querySelector('[name="cf-turnstile-response"]');
      return response && response.value.length > 0;
    }, { timeout: 30000 });

    console.log('Turnstile superato con successo!');
    
    // Ulteriori azioni sul sito
    await humanLikeDelay();
    
    // Esempio: compilazione del modulo
    await page.fill('#email', 'user@example.com');
    await humanLikeDelay(500, 1500);
    
    await page.fill('#password', 'SecurePassword123');
    await humanLikeDelay(500, 1500);
    
    await humanLikeMouseMove();
    await page.click('button[type="submit"]');
    
    await page.waitForNavigation({ waitUntil: 'networkidle' });
    
    console.log('Autenticazione completata');

  } catch (error) {
    console.error('Errore durante il bypass di Turnstile:', error.message);
    
    // Screenshot per il debug
    await page.screenshot({ path: 'turnstile_error.png', fullPage: true });
    
  } finally {
    await browser.close();
  }
}

// Avvio
bypassTurnstile('https://example.com/login');

Per hCaptcha con compiti visivi sarà necessaria l'integrazione di un servizio di risoluzione. Ecco un esempio con 2Captcha:

const axios = require('axios');

class HCaptchaSolver {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2captcha.com';
  }

  async solve(sitekey, pageUrl, proxy = null) {
    // Creazione del compito
    const params = {
      key: this.apiKey,
      method: 'hcaptcha',
      sitekey: sitekey,
      pageurl: pageUrl,
      json: 1
    };

    if (proxy) {
      params.proxy = `${proxy.type}:${proxy.host}:${proxy.port}:${proxy.username}:${proxy.password}`;
      params.proxytype = proxy.type.toUpperCase();
    }

    const createResponse = await axios.post(`${this.baseUrl}/in.php`, null, { params });
    
    if (createResponse.data.status !== 1) {
      throw new Error(`Errore nella creazione del compito: ${createResponse.data.request}`);
    }

    const taskId = createResponse.data.request;
    console.log(`Compito creato: ${taskId}`);

    // Polling del risultato
    for (let attempt = 0; attempt < 60; attempt++) {
      await new Promise(resolve => setTimeout(resolve, 5000));

      const resultResponse = await axios.get(`${this.baseUrl}/res.php`, {
        params: {
          key: this.apiKey,
          action: 'get',
          id: taskId,
          json: 1
        }
      });

      if (resultResponse.data.status === 1) {
        console.log('hCaptcha risolta!');
        return resultResponse.data.request;
      }

      if (resultResponse.data.request !== 'CAPCHA_NOT_READY') {
        throw new Error(`Errore nella risoluzione: ${resultResponse.data.request}`);
      }

      console.log(`Tentativo ${attempt + 1}/60: la captcha è ancora in fase di risoluzione...`);
    }

    throw new Error('Timeout: captcha non risolta entro 5 minuti');
  }
}

// Utilizzo con Playwright
async function bypassHCaptcha(page, proxyConfig) {
  // Ottenimento del sitekey dalla pagina
  const sitekey = await page.getAttribute('[data-sitekey]', 'data-sitekey');
  const pageUrl = page.url();

  const solver = new HCaptchaSolver('your_2captcha_api_key');
  
  const token = await solver.solve(sitekey, pageUrl, {
    type: 'http',
    host: 'residential-proxy.proxycove.com',
    port: 8080,
    username: 'your_username',
    password: 'your_password'
  });

  // Iniezione del token nella pagina
  await page.evaluate((captchaToken) => {
    document.querySelector('[name="h-captcha-response"]').value = captchaToken;
    
    // Per alcuni siti è necessario anche g-recaptcha-response
    const gRecaptcha = document.querySelector('[name="g-recaptcha-response"]');
    if (gRecaptcha) {
      gRecaptcha.value = captchaToken;
    }
    
    // Attivazione dell'evento per callback
    const event = new Event('change', { bubbles: true });
    document.querySelector('[name="h-captcha-response"]').dispatchEvent(event);
  }, token);

  console.log('Token hCaptcha iniettato');
}

Conclusione

Il bypass di Turnstile e hCaptcha tramite proxy è un compito complesso che richiede comprensione dei meccanismi di protezione e una combinazione intelligente di tecnologie. Le conclusioni chiave: utilizza proxy residenziali o mobili di qualità invece di proxy di data center; sincronizza tutti i parametri ambientali (geolocalizzazione IP, fuso orario, lingua, località); applica tecniche anti-detect per nascondere l'automazione; emula un comportamento umano realistico; utilizza servizi di risoluzione captcha come ulteriore livello di protezione.

L'efficacia dei metodi dipende dal sito specifico e dalle impostazioni di protezione. Si consiglia di iniziare con una configurazione di base e di complicare progressivamente, monitorando il tasso di successo. Testa su piccole quantità prima di scalare, per evitare il blocco del pool di IP. Aggiorna regolarmente i parametri di fingerprint e l'User-Agent per le versioni attuali dei browser.

Per un lavoro professionale con le captcha, considera l'uso di piattaforme di automazione specializzate che combinano proxy, browser anti-detect e servizi di risoluzione in un'unica ecosistema. Questo riduce la complessità dell'integrazione e aumenta la stabilità dei risultati. Inizia con testare proxy di qualità sui tuoi siti target — questo è il fondamento per un bypass di successo dei moderni sistemi di protezione.