Contournement de Turnstile et hCaptcha : technologies de protection et méthodes de contournement

Cloudflare Turnstile et hCaptcha sont devenus la norme pour protéger les services web contre les bots, remplaçant la traditionnelle reCAPTCHA. Ces systèmes analysent des dizaines de paramètres du navigateur et de l'environnement réseau, rendant l'utilisation de proxies un défi sérieux pour l'automatisation. Dans cet article, nous allons examiner comment ces technologies fonctionnent au niveau technique et quelles méthodes de contournement sont réellement efficaces lors de l'utilisation de proxies.

Comment fonctionne Cloudflare Turnstile

Cloudflare Turnstile est un système de protection de nouvelle génération, qui se positionne comme une "alternative invisible à CAPTCHA". Contrairement à la classique reCAPTCHA, Turnstile ne demande pas à l'utilisateur de sélectionner des feux de circulation ou des passages piétons. Au lieu de cela, le système analyse les caractéristiques comportementales et techniques du navigateur en arrière-plan.

Techniquement, Turnstile fonctionne en trois étapes. La première consiste à charger un widget JavaScript, qui est intégré à la page via un iframe. La deuxième étape est la collecte de télémétrie : le système collecte des données sur le navigateur, y compris le fingerprint WebGL, le fingerprint Canvas, la liste des polices, la résolution de l'écran, le fuseau horaire, la langue du système et de nombreux autres paramètres. La troisième étape est la validation sur les serveurs de Cloudflare, où les données collectées sont comparées à des modèles connus de bots et de proxies.

La caractéristique clé de Turnstile est l'utilisation d'un système de réputation des adresses IP. Cloudflare dispose d'une immense base de données, collectée à partir de millions de sites utilisant leur CDN et leur protection contre les DDoS. Si une adresse IP est remarquée pour une activité suspecte, la probabilité de passer Turnstile diminue fortement. Cela crée le premier problème pour les utilisateurs de proxies : même des IP résidentielles propres peuvent avoir une mauvaise réputation en raison de leurs anciens propriétaires.

Technologie hCaptcha et méthodes de détection

hCaptcha est apparu comme un concurrent de Google reCAPTCHA, mettant l'accent sur la confidentialité et la monétisation via l'apprentissage automatique. Le système propose aux propriétaires de sites de payer pour l'utilisation des données des utilisateurs afin de former des modèles d'IA. D'un point de vue technique, hCaptcha est plus agressif dans la détection de l'automatisation que Turnstile.

Le mécanisme principal de fonctionnement de hCaptcha comprend plusieurs niveaux de protection. Le premier niveau est la vérification des paramètres réseau : le système analyse le TTL des paquets, les latences réseau, la cohérence de la géolocalisation de l'adresse IP et le fuseau horaire déclaré du navigateur. Le deuxième niveau concerne les appels JavaScript : hCaptcha vérifie la présence et le bon fonctionnement des API Web, y compris WebRTC, Battery API, Sensor API. Le troisième niveau est l'analyse comportementale des mouvements de la souris, de la vitesse de défilement et des motifs de clics.

Une particularité de hCaptcha est l'utilisation de vérifications basées sur des défis. Si le système soupçonne un bot, il affiche des tâches visuelles : sélection d'images avec des objets spécifiques, résolution de puzzles, reconnaissance de texte sur des images déformées. La difficulté des tâches augmente dynamiquement après chaque tentative échouée. Pour les utilisateurs de proxies, cela signifie que même avec un bon fingerprint, on peut se retrouver avec une chaîne infinie de captchas.

Fingerprinting du navigateur et proxies

Le fingerprinting du navigateur est une technique d'identification de l'utilisateur basée sur un ensemble unique de caractéristiques du navigateur et de l'appareil. Même si vous utilisez un proxy pour changer d'adresse IP, le fingerprint reste inchangé et peut révéler l'utilisation de l'automatisation. Les systèmes de protection modernes collectent entre 50 et 200+ paramètres pour créer un fingerprint.

Les principaux composants du fingerprint incluent : le fingerprint Canvas (rendu graphique unique, dépendant du GPU et des pilotes), le fingerprint WebGL (paramètres de l'accélérateur graphique), le fingerprint Audio Context (caractéristiques du traitement audio), la liste des polices installées, les paramètres de l'écran (résolution, profondeur de couleur, ratio de pixels), User-Agent et en-têtes du navigateur, paramètres linguistiques, fuseau horaire, présence de plugins et d'extensions.

Le problème pour les utilisateurs de proxies réside dans les incohérences. Par exemple, si votre adresse IP montre une localisation en Allemagne, mais que le fuseau horaire du navigateur est réglé sur Moscou, c'est un signal d'alerte. Si une fuite WebRTC révèle votre véritable adresse IP, différente de celle du proxy, le système identifiera instantanément la substitution. Si le User-Agent déclare Windows, mais que le fingerprint Canvas correspond à Linux, la détection est garantie.

// Exemple de collecte d'un fingerprint de 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('Fingerprint du navigateur', 2, 2);
  return canvas.toDataURL();
}

Méthodes de détection des serveurs proxy

Les systèmes de protection utilisent de nombreuses techniques pour détecter les proxies. La première méthode consiste à vérifier les bases de données de proxies et de VPN connus. Des services comme IPHub, IP2Proxy, MaxMind GeoIP2 contiennent des millions d'adresses IP classées comme proxies, VPN, fournisseurs d'hébergement. Cloudflare et hCaptcha sont intégrés à ces bases et augmentent automatiquement le niveau de vérification pour les IP suspectes.

La deuxième méthode consiste à analyser l'ASN (Numéro de Système Autonome). Les proxies de centres de données appartiennent généralement à des fournisseurs d'hébergement (AWS, DigitalOcean, OVH), ce qui est facilement identifiable par l'ASN. Les proxies résidentiels utilisent l'ASN des fournisseurs d'accès Internet ordinaires (Comcast, Verizon, Deutsche Telekom), ce qui les rend moins suspects. Cependant, même les réseaux résidentiels peuvent être partiellement compromis si le fournisseur est connu pour vendre des proxies.

La troisième méthode est l'analyse comportementale au niveau du réseau. Les systèmes surveillent les anomalies : TTL des paquets trop bas ou trop élevés, latences atypiques, utilisation de ports non standards, incohérence de la géolocalisation et du chemin de routage. Par exemple, si une adresse IP est géolocalisée aux États-Unis, mais que le traceroute montre un chemin à travers des serveurs européens, c'est un signe de proxy.

Proxies résidentiels comme solution de base

Les proxies résidentiels sont la base pour contourner Turnstile et hCaptcha. Contrairement aux proxies de centres de données, les résidentiels utilisent des adresses IP d'appareils réels : routeurs domestiques, téléphones mobiles, appareils IoT. Cela les rend pratiquement indiscernables des utilisateurs ordinaires du point de vue de l'infrastructure réseau.

Les principaux avantages des proxies résidentiels pour contourner les captchas : appartenance à un FAI (Fournisseur d'Accès Internet) et non à des fournisseurs d'hébergement ; réputation IP propre dans la plupart des cas ; géolocalisation et routage corrects ; faible probabilité d'être mis sur liste noire. Cependant, tous les proxies résidentiels ne sont pas également efficaces. Plusieurs facteurs sont critiques.

Le premier facteur est la rotation des adresses IP. Les proxies résidentiels statiques (sessions collantes) permettent d'utiliser une seule IP pendant plusieurs minutes à plusieurs heures. Cela est optimal pour les scénarios nécessitant le maintien de sessions : authentification, remplissage de formulaires, opérations en plusieurs étapes. Les proxies rotatifs changent d'IP à chaque requête ou selon un minuteur, ce qui est utile pour le scraping, mais peut poser des problèmes avec les captchas en raison du changement fréquent de contexte.

Le deuxième facteur est la répartition géographique. Pour contourner les captchas, il est important que la géolocalisation de l'IP corresponde à la cible du site et aux paramètres du navigateur. Si vous travaillez avec un site allemand, utilisez des proxies résidentiels allemands et définissez le fuseau horaire approprié (Europe/Berlin), la langue (de-DE) et la locale dans le navigateur.

Le troisième facteur est la qualité du fournisseur de proxy. Les proxies résidentiels bon marché sont souvent collectés par des méthodes douteuses (applications VPN gratuites, appareils infectés), ce qui entraîne une mauvaise réputation du pool d'IP. Les fournisseurs professionnels travaillent avec des partenariats SDK légitimes et surveillent soigneusement la qualité du réseau. Vérifiez le taux de réussite du fournisseur sur les sites cibles avant de passer à l'échelle.

Outils d'automatisation : Selenium, Puppeteer, Playwright

Le choix de l'outil d'automatisation influence de manière critique la capacité à contourner les captchas. Selenium, Puppeteer et Playwright sont trois solutions principales, chacune avec ses propres caractéristiques de détection. Les systèmes de protection savent identifier l'utilisation de ces outils par des dizaines de signes.

Selenium est l'outil le plus ancien et le plus facilement détectable. Un navigateur contrôlé par Selenium a des marqueurs évidents : la variable window.navigator.webdriver est définie sur true, certaines propriétés de l'objet navigator sont absentes, des tailles de fenêtre spécifiques à l'automatisation. Même avec un proxy, Selenium échoue souvent aux vérifications de Turnstile et hCaptcha sans obfuscation supplémentaire.

Puppeteer et Playwright sont des outils plus modernes basés sur le Chrome DevTools Protocol. Ils sont également détectables, mais ont moins de signes évidents. Les principales méthodes de détection : vérification de chrome.runtime, analyse de l'API des permissions, détection du mode headless par l'absence de plugins et des tailles de viewport spécifiques, vérification de la présence de DevTools par des attaques de timing.

// Configuration de base de Puppeteer avec proxy et anti-détection
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
  headless: false, // headless: true est facilement détecté
  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();

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

// Redéfinition de la propriété webdriver
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => false
  });
  
  // Émulation des plugins pour headless
  Object.defineProperty(navigator, 'plugins', {
    get: () => [1, 2, 3, 4, 5]
  });
});

Pour un contournement sérieux des captchas, il est recommandé d'utiliser des navigateurs anti-détection spécialisés : Multilogin, GoLogin, AdsPower, Dolphin Anty. Ces solutions créent des profils de navigateur isolés avec des fingerprints uniques, gèrent les cookies et le stockage de session, synchronisent automatiquement le fuseau horaire avec la géolocalisation du proxy, et émulent des Canvas et WebGL fingerprints réalistes.

Services de résolution de captcha : intégration et efficacité

Lorsque les méthodes techniques ne suffisent pas, les services de résolution de captcha entrent en jeu. Ils se divisent en deux types : humains (crowdsourcing) et automatiques (apprentissage automatique). Pour Turnstile et hCaptcha, l'efficacité varie.

Les services humains (2Captcha, AntiCaptcha, CapSolver, CapMonster Cloud) fonctionnent sur le principe du travail distribué : votre captcha est envoyé à une personne réelle qui le résout manuellement. Avantages : taux de réussite élevé (95-99 % pour hCaptcha, 85-95 % pour Turnstile), prise en charge de tâches visuelles complexes, stabilité relative. Inconvénients : temps de résolution de 10 à 60 secondes, coût de 1 à 3 $ pour 1000 captchas, dépendance à la disponibilité des opérateurs.

Les services automatiques utilisent des modèles d'IA pour la reconnaissance. Ils sont plus rapides (1-5 secondes) et moins chers, mais ont un taux de réussite inférieur pour les captchas modernes — généralement 60-80 % pour hCaptcha et 50-70 % pour Turnstile. Ils sont efficaces pour des tâches simples basées sur des défis, mais échouent souvent sur des vérifications invisibles.

// Intégration de 2Captcha pour résoudre hCaptcha
const axios = require('axios');

async function solveHCaptcha(sitekey, pageUrl, proxyConfig) {
  const API_KEY = 'your_2captcha_api_key';
  
  // Envoi de la tâche
  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;
  
  // Attente de la solution
  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 à insérer dans le formulaire
}

// Utilisation dans 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);

Il est crucial de transmettre les bons paramètres de proxy au service de résolution de captcha. Si le captcha est résolu avec une IP, puis que le token est utilisé avec une autre — la validation échouera. Les captchas modernes lient le token à l'adresse IP, au User-Agent et à d'autres paramètres de session.

Techniques avancées : émulation d'appareils et TLS fingerprinting

Pour contourner les systèmes les plus protégés, des techniques avancées sont nécessaires, allant au-delà de la configuration de base des proxies et des navigateurs. Deux domaines clés sont l'émulation d'appareils mobiles et la gestion du TLS fingerprint.

Les proxies mobiles combinés à l'émulation de navigateurs mobiles offrent une efficacité élevée contre les captchas. Raisons : le trafic mobile a un score de confiance plus élevé, les adresses IP mobiles (surtout 4G/5G) sont souvent dynamiques et changent naturellement, les appareils mobiles ont un ensemble différent de paramètres de fingerprint, de nombreux sites simplifient les vérifications pour les utilisateurs mobiles.

Pour une émulation correcte d'un appareil mobile, il est nécessaire : d'utiliser un User-Agent mobile (correspondance exacte avec le modèle de l'appareil), de définir un viewport et un devicePixelRatio corrects, d'émuler des événements tactiles au lieu d'événements de souris, d'utiliser des valeurs mobiles pour navigator.platform et navigator.maxTouchPoints, de configurer le WebGL et le Canvas fingerprint pour un modèle d'appareil spécifique.

// Émulation d'un iPhone 13 Pro dans 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();

// Configuration supplémentaire du fingerprint
await page.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', {
    get: () => 6 // l'iPhone 13 Pro a 6 cœurs
  });
  
  Object.defineProperty(navigator, 'deviceMemory', {
    get: () => 6 // 6 Go de RAM
  });
});

Le TLS fingerprinting est une méthode d'identification du client basée sur les paramètres de la connexion TLS/SSL. Chaque navigateur et système d'exploitation a une combinaison unique de suites de chiffrement, d'extensions, de courbes elliptiques, qui sont transmises lors de l'établissement d'une connexion HTTPS. Les systèmes de protection analysent le TLS fingerprint et le comparent au User-Agent déclaré.

Le problème des outils d'automatisation standard est qu'ils utilisent le TLS fingerprint de base de Chromium, qui diffère de celui de Chrome complet. Cette incohérence est détectable. Solutions : utilisation de bibliothèques comme curl-impersonate ou tls-client pour Python, qui émulent le TLS fingerprint de navigateurs spécifiques ; utilisation de clients HTTP avec personnalisation TLS (par exemple, cycletls pour Node.js) ; utilisation de navigateurs complets au lieu de modes headless.

Exemples pratiques de code

Examinons un exemple complet de contournement de Turnstile utilisant Playwright, des proxies résidentiels et des techniques anti-détection. Ce code démontre une approche globale pour résoudre le problème.

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

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

// Paramètres pour imiter un utilisateur réel d'Allemagne
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 }, // Berlin
  permissions: ['geolocation']
};

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

  const context = await browser.newContext({
    ...userConfig,
    // En-têtes supplémentaires
    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();

  // Injection de scripts anti-détection
  await page.addInitScript(() => {
    // Masquage du webdriver
    Object.defineProperty(navigator, 'webdriver', {
      get: () => undefined
    });

    // Émulation du runtime chrome
    window.chrome = {
      runtime: {}
    };

    // Redéfinition des permissions
    const originalQuery = window.navigator.permissions.query;
    window.navigator.permissions.query = (parameters) => (
      parameters.name === 'notifications' ?
        Promise.resolve({ state: Notification.permission }) :
        originalQuery(parameters)
    );

    // Valeurs plus réalistes pour Windows
    Object.defineProperty(navigator, 'platform', {
      get: () => 'Win32'
    });

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

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

  // Émulation du comportement humain
  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 {
    // Accès à la page
    await page.goto(url, { waitUntil: 'networkidle' });
    
    await humanLikeDelay(2000, 4000);
    await humanLikeMouseMove();

    // Attente du chargement de Turnstile
    await page.waitForSelector('iframe[src*="turnstile"]', { timeout: 10000 });
    
    console.log('Turnstile détecté, attente de la résolution automatique...');
    
    // Turnstile en mode managed est souvent résolu automatiquement
    // Attente de l'apparition du token
    await page.waitForFunction(() => {
      const response = document.querySelector('[name="cf-turnstile-response"]');
      return response && response.value.length > 0;
    }, { timeout: 30000 });

    console.log('Turnstile passé avec succès !');
    
    // Actions ultérieures sur le site
    await humanLikeDelay();
    
    // Exemple : remplissage d'un formulaire
    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('Authentification réussie');

  } catch (error) {
    console.error('Erreur lors du contournement de Turnstile :', error.message);
    
    // Capture d'écran pour débogage
    await page.screenshot({ path: 'turnstile_error.png', fullPage: true });
    
  } finally {
    await browser.close();
  }
}

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

Pour hCaptcha avec des tâches visuelles, une intégration du service de résolution sera nécessaire. Voici un exemple utilisant 2Captcha :

const axios = require('axios');

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

  async solve(sitekey, pageUrl, proxy = null) {
    // Création de la tâche
    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(`Erreur lors de la création de la tâche : ${createResponse.data.request}`);
    }

    const taskId = createResponse.data.request;
    console.log(`Tâche créée : ${taskId}`);

    // Polling du résultat
    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 résolue !');
        return resultResponse.data.request;
      }

      if (resultResponse.data.request !== 'CAPCHA_NOT_READY') {
        throw new Error(`Erreur de résolution : ${resultResponse.data.request}`);
      }

      console.log(`Tentative ${attempt + 1}/60 : captcha en cours de résolution...`);
    }

    throw new Error('Délai dépassé : captcha non résolue en 5 minutes');
  }
}

// Utilisation avec Playwright
async function bypassHCaptcha(page, proxyConfig) {
  // Récupération du sitekey depuis la page
  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'
  });

  // Injection du token dans la page
  await page.evaluate((captchaToken) => {
    document.querySelector('[name="h-captcha-response"]').value = captchaToken;
    
    // Pour certains sites, il peut également être nécessaire d'inclure g-recaptcha-response
    const gRecaptcha = document.querySelector('[name="g-recaptcha-response"]');
    if (gRecaptcha) {
      gRecaptcha.value = captchaToken;
    }
    
    // Déclenchement de l'événement pour le callback
    const event = new Event('change', { bubbles: true });
    document.querySelector('[name="h-captcha-response"]').dispatchEvent(event);
  }, token);

  console.log('Token hCaptcha injecté');
}

Conclusion

Contourner Turnstile et hCaptcha via des proxies est une tâche complexe qui nécessite une compréhension des mécanismes de protection et une combinaison judicieuse des technologies. Principales conclusions : utilisez des proxies résidentiels ou mobiles de qualité au lieu de proxies de centres de données ; synchronisez tous les paramètres d'environnement (géolocalisation IP, fuseau horaire, langue, locale) ; appliquez des techniques anti-détection pour masquer l'automatisation ; émulez un comportement humain réaliste ; utilisez des services de résolution de captcha comme niveau de protection supplémentaire.

L'efficacité des méthodes dépend du site spécifique et des paramètres de protection. Il est recommandé de commencer par une configuration de base et d'augmenter progressivement la complexité, en surveillant le taux de réussite. Testez sur de petits volumes avant de passer à l'échelle pour éviter le blocage du pool d'IP. Mettez régulièrement à jour les paramètres de fingerprint et le User-Agent en fonction des versions actuelles des navigateurs.

Pour un travail professionnel avec les captchas, envisagez d'utiliser des plateformes d'automatisation spécialisées qui combinent proxies, navigateurs anti-détection et services de résolution en un écosystème unique. Cela réduit la complexité de l'intégration et améliore la stabilité des résultats. Commencez par tester des proxies de qualité sur vos sites cibles — c'est la base d'un contournement réussi des systèmes de protection modernes.