Contournement de la protection PerimeterX et Akamai : méthodes pratiques d'anti-détection

PerimeterX et Akamai Bot Manager sont deux des solutions de protection contre les bots les plus avancées, utilisées par les plus grandes plateformes de commerce électronique, services financiers et sites d'entreprise. Ces systèmes analysent des centaines de paramètres du navigateur, du comportement des utilisateurs et des caractéristiques réseau, créant une protection multicouche qui ne peut être contournée simplement en changeant l'adresse IP.

Dans ce guide, nous examinerons en détail l'architecture des deux systèmes, étudierons leurs méthodes de détection et créerons une stratégie de contournement complète, basée sur des cas réels et des expériences techniques.

Architecture de PerimeterX et Akamai : comment fonctionne la détection

PerimeterX (maintenant HUMAN Security) et Akamai Bot Manager fonctionnent comme des systèmes de protection multicouches, s'intégrant à différentes étapes du traitement de la requête. Comprendre leur architecture est crucial pour développer une stratégie de contournement.

Architecture de PerimeterX

PerimeterX fonctionne en trois étapes. Dans la première étape, un capteur JavaScript est intégré à la page HTML et s'exécute dans le navigateur du client, collectant des données sur l'environnement d'exécution : empreinte WebGL, empreinte Canvas, contexte audio, polices disponibles, plugins, résolution d'écran et de nombreux autres paramètres. Ce capteur est obfusqué et mis à jour régulièrement, ce qui rend son analyse difficile.

À la deuxième étape, le composant serveur de PerimeterX analyse les en-têtes HTTP, l'empreinte TLS, la réputation IP et les caractéristiques réseau avant même que la requête n'atteigne l'application principale. Le système utilise sa propre base de données de bots connus et d'adresses IP suspectes, mise à jour en temps réel.

La troisième étape est l'analyse comportementale. PerimeterX suit les mouvements de la souris, la vitesse de défilement, les modèles de clics, le temps entre les actions et construit un profil de comportement. Les modèles d'apprentissage automatique comparent ce profil aux modèles d'utilisateurs réels et de bots connus.

Architecture d'Akamai Bot Manager

Akamai Bot Manager s'intègre au niveau CDN, ce qui lui donne un avantage en termes de vitesse d'analyse. Le système utilise sa propre technologie BMP (Bot Manager Premier), qui analyse les requêtes sur les serveurs frontaliers d'Akamai avant leur transmission au serveur d'origine.

La principale différence d'Akamai est l'utilisation de la télémétrie provenant de millions de sites protégés par leur CDN. Cela permet au système d'identifier rapidement de nouveaux types de bots et de mettre à jour les règles de détection à l'échelle mondiale. Akamai utilise également une technologie Web SDK, similaire au capteur PerimeterX, mais avec un accent sur la vérification cryptographique de l'intégrité du client.

Méthodes de détection : ce que les systèmes de protection analysent

Les systèmes anti-bots modernes analysent les requêtes selon des centaines de paramètres, regroupés en plusieurs catégories. Comprendre chaque catégorie permet d'éliminer systématiquement les marqueurs d'automatisation.

Analyse des en-têtes HTTP et TLS

L'ordre des en-têtes HTTP est l'un des moyens les plus simples de détection. Les navigateurs envoient des en-têtes dans un ordre strictement défini, qui diffère selon les versions et les fabricants. Les bibliothèques comme requests en Python ou axios en Node.js utilisent leur propre ordre, révélant instantanément l'automatisation.

L'empreinte TLS (empreinte JA3) est créée à partir des paramètres de la poignée de main TLS : version TLS, liste des suites de chiffrement prises en charge, extensions et leur ordre. Chaque combinaison de navigateur et de système d'exploitation crée une empreinte unique. Par exemple, Chrome 120 sur Windows 11 a une empreinte différente de Chrome 120 sur macOS ou de Firefox sur le même système.

// Exemple de non-concordance entre User-Agent et empreinte TLS
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: L'empreinte JA3 correspond aux requêtes Python
// Résultat : blocage immédiat

Environnement d'exécution JavaScript

Les navigateurs sans tête laissent des dizaines de traces dans l'environnement JavaScript. Les propriétés navigator.webdriver, la présence d'objets window.chrome, les incohérences dans navigator.plugins, et les anomalies dans le rendu WebGL et Canvas sont vérifiées.

PerimeterX et Akamai utilisent des techniques avancées de vérification : mesurent le temps d'exécution des fonctions JavaScript (dans les navigateurs sans tête, il diffère), vérifient la présence d'artefacts d'automatisation dans le DOM, et analysent la pile d'appels de fonctions. Les systèmes vérifient également la cohérence des données — par exemple, si le User-Agent indique un appareil mobile, mais que navigator.maxTouchPoints est égal à 0, cela déclenche une détection.

Caractéristiques réseau et réputation IP

Les systèmes de protection vérifient l'adresse IP selon de nombreux paramètres : appartenance à des fournisseurs de proxy connus, présence sur des listes noires, historique d'activité depuis cette IP, cohérence de la géolocalisation avec d'autres paramètres de la requête (langue du navigateur, fuseau horaire).

Une attention particulière est accordée aux modèles d'utilisation de l'IP. Si des requêtes proviennent d'une même adresse avec différents User-Agent ou empreintes de navigateur, c'est un signal fort d'automatisation. De même, si l'IP change trop souvent au cours d'une même session (rotation agressive des proxies), cela déclenche un blocage.

Empreintes de navigateur et empreintes TLS

L'empreinte de navigateur est une technique de création d'un identifiant unique pour le navigateur basé sur ses caractéristiques. Même sans cookies, les systèmes de protection peuvent suivre les utilisateurs et détecter des anomalies.

Empreintes Canvas et WebGL

L'empreinte Canvas fonctionne en rendant une image invisible avec du texte et des graphiques. En raison des différences dans les pilotes graphiques, les polices et les paramètres d'anti-aliasing, chaque système crée une image légèrement différente. Le hachage de cette image devient une partie de l'empreinte.

L'empreinte WebGL utilise le rendu 3D pour créer une empreinte encore plus unique. Le système demande des informations sur le GPU, les extensions prises en charge, les tailles maximales des textures et d'autres paramètres. La combinaison de ces données crée une empreinte avec une entropie suffisante pour identifier le dispositif.

// Exemple d'obtention de l'empreinte WebGL
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// Le résultat peut être : "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Combinaison unique pour chaque dispositif

Contexte audio et polices

L'API Audio Context permet de créer une empreinte unique basée sur le traitement du son. Les différences dans la pile audio du système d'exploitation entraînent des différences microscopiques dans le traitement du signal audio, qui peuvent être mesurées et utilisées pour l'identification.

La liste des polices installées est également unique à chaque système. Les systèmes de protection utilisent une technique de mesure des tailles de texte avec différentes polices — si la police n'est pas installée, le navigateur utilise un fallback, ce qui modifie les tailles. Vérifier des centaines de polices crée une signature unique.

Empreintes TLS et HTTP/2

L'empreinte JA3 est créée à partir des paramètres TLS Client Hello : version SSL/TLS, liste des suites de chiffrement, liste des extensions, liste des groupes de courbes elliptiques prises en charge, formats des points de courbes elliptiques. Ces paramètres sont concaténés et hachés, créant une chaîne unique.

L'empreinte HTTP/2 analyse les paramètres du cadre SETTINGS, l'ordre et les priorités des flux, les valeurs de mise à jour de fenêtre. Chaque navigateur utilise des paramètres HTTP/2 uniques, ce qui permet d'identifier le client même avec une empreinte TLS correcte.

Analyse comportementale et apprentissage automatique

L'analyse comportementale est l'aspect le plus difficile à contourner des systèmes anti-bots modernes. Même avec une empreinte technique parfaite, un comportement non humain révélera l'automatisation.

Analyse des mouvements de la souris et des interactions

PerimeterX et Akamai suivent les trajectoires des mouvements de la souris, l'accélération et le ralentissement, les micro-mouvements caractéristiques de la main humaine. Les bots déplacent généralement le curseur en ligne droite ou ne génèrent pas d'événements de souris du tout. Les systèmes analysent également le temps de réaction — un clic juste après le chargement de la page sans mouvement de la souris semble suspect.

Les modèles de défilement sont également uniques. Un humain fait défiler la page de manière inégale : rapidement au début, ralentit pour lire, parfois fait défiler en arrière. Les bots défilent généralement à une vitesse constante ou utilisent window.scrollTo() pour un défilement instantané.

Modèles temporels et vitesse des actions

Le temps entre les actions est un paramètre critique. Un humain ne peut pas remplir un formulaire de 10 champs en 0,5 seconde ou cliquer sur 50 liens en une minute. Les systèmes de protection construisent un profil de vitesse pour chaque type d'action et le comparent au comportement de l'utilisateur.

Une attention particulière est accordée à la cohérence des délais. Si chaque clic prend exactement 2 secondes, c'est un signe évident de sleep(2000) dans le code. Les délais humains ont une variabilité naturelle et suivent certaines distributions statistiques.

Modèles d'apprentissage automatique

Les deux systèmes utilisent des modèles d'apprentissage automatique, formés sur des millions de sessions d'utilisateurs réels et de bots connus. Les modèles analysent des centaines de caractéristiques simultanément : séquence des actions, profondeur de navigation sur le site, modèles de navigation, interaction avec les éléments.

PerimeterX utilise un ensemble de modèles avec des poids différents pour différents types de sites. Le modèle pour le commerce électronique se concentre sur les modèles d'achat, le modèle pour les sites médiatiques se concentre sur les modèles de lecture de contenu. Cela rend le contournement plus complexe, car cela nécessite une adaptation à la spécificité de chaque site.

// Exemple de délais humains avec variabilité
function humanDelay(baseMs) {
  // Distribution log-normale au lieu de uniforme
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Ajout de micro-délai caractéristiques du traitement des événements par le navigateur
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

// Utilisation : await new Promise(r => setTimeout(r, humanDelay(2000)));

Stratégie de sélection et de rotation des proxies

Le choix du type de proxy et de la stratégie de rotation est crucial lors de l'utilisation de PerimeterX et Akamai. Une mauvaise configuration des proxies annulera tous les efforts de masquage de l'empreinte du navigateur.

Proxies résidentiels vs mobiles vs datacenter

Les proxies datacenter ont le coût le plus bas, mais aussi le risque de détection le plus élevé. PerimeterX et Akamai maintiennent des bases de données d'adresses IP de datacenters et augmentent automatiquement le niveau de vérification pour de telles requêtes. L'utilisation de proxies datacenter n'est possible que pour des tâches de faible priorité ou en combinaison avec une empreinte de navigateur de très haute qualité.

Les proxies résidentiels utilisent des adresses IP de véritables fournisseurs d'accès Internet, ce qui réduit considérablement la probabilité de détection. Cependant, la qualité des proxies résidentiels varie fortement. Il est important de choisir des fournisseurs avec des pools IP propres, où les adresses n'ont pas été utilisées auparavant pour du spam ou d'autres activités suspectes.

Les proxies mobiles offrent le plus haut niveau de confiance, car ils utilisent des adresses IP des opérateurs mobiles. Ces adresses sont généralement partagées entre de nombreux utilisateurs (NAT de niveau opérateur), ce qui rend le blocage difficile. Les proxies mobiles sont particulièrement efficaces contre Akamai, qui est plus prudent en ce qui concerne le blocage du trafic mobile.

Stratégies de rotation

Une rotation agressive (changement d'IP à chaque requête) est une erreur courante. Cela crée un modèle suspect : un utilisateur ne peut pas physiquement changer d'adresse IP toutes les quelques secondes. Une rotation de session est plus efficace, où une seule IP est utilisée pour toute la session utilisateur (10-30 minutes d'activité).

Pour des opérations prolongées, il est recommandé d'utiliser des sessions collantes d'une durée de 30 à 60 minutes. Cela imite le comportement d'un utilisateur réel qui reste sur une même IP pendant la session. Il est important de ne pas utiliser une seule IP trop longtemps — des sessions de plusieurs heures semblent également suspectes.

Cohérence géographique

Il est crucial d'assurer la correspondance entre la géolocalisation de l'adresse IP et d'autres paramètres : langue du navigateur, fuseau horaire, paramètres de locale. Si l'adresse IP provient d'Allemagne, mais que navigator.language renvoie "en-US" et le fuseau horaire "America/New_York" — c'est un déclencheur immédiat de détection.

Lors de l'utilisation de plusieurs régions géographiques, utilisez des profils de navigateur distincts pour chaque région. Passer d'une région à l'autre au sein d'une même session (IP de France, puis du Japon) est impossible pour un utilisateur réel et est immédiatement détecté.

Configuration des navigateurs et outils anti-détection

La configuration correcte des outils d'automatisation est un facteur clé pour le contournement réussi de PerimeterX et Akamai. Même les meilleurs proxies ne seront d'aucune aide si l'empreinte du navigateur contient des marqueurs évidents d'automatisation.

Playwright et Puppeteer : configuration avancée

Une installation de base de Playwright ou Puppeteer crée un navigateur sans tête évident. Il est nécessaire d'utiliser des plugins stealth et une configuration supplémentaire pour masquer l'automatisation. La bibliothèque puppeteer-extra-plugin-stealth cache les principaux marqueurs, mais nécessite une configuration supplémentaire.

// Configuration avancée de Playwright avec anti-détection
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // Le mode sans tête est facilement détecté
  args: [
    '--disable-blink-features=AutomationControlled',
    '--disable-features=IsolateOrigins,site-per-process',
    '--disable-site-isolation-trials',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-dev-shm-usage',
    '--disable-accelerated-2d-canvas',
    '--disable-gpu',
    '--window-size=1920,1080',
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

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

Selenium avec undetected-chromedriver

Le WebDriver Selenium standard est facilement détecté via la propriété navigator.webdriver. La bibliothèque undetected-chromedriver patch automatiquement ChromeDriver, supprimant les principaux marqueurs d'automatisation et est régulièrement mise à jour pour contourner de nouvelles méthodes de détection.

import undetected_chromedriver as uc
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
options.add_argument('--window-size=1920,1080')

# Utilisation d'une version spécifique de Chrome pour la cohérence
driver = uc.Chrome(options=options, version_main=120)

# Masquage supplémentaire via CDP
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})

driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

Navigateurs anti-détection : AdsPower, Multilogin, GoLogin

Les navigateurs anti-détection commerciaux fournissent des solutions prêtes à l'emploi pour gérer les empreintes. AdsPower et Multilogin permettent de créer des profils avec des empreintes Canvas, WebGL, audio uniques et de les gérer via API. Ces outils sont particulièrement utiles lors de la gestion de plusieurs comptes.

L'avantage clé est la possibilité de conserver une empreinte cohérente entre les sessions. Chaque profil a des paramètres fixes pour Canvas, WebGL, fonts, ce qui est critique pour un travail à long terme. Il est important d'utiliser des configurations réalistes — la génération d'empreintes aléatoires peut créer des combinaisons techniquement impossibles, qui sont facilement détectées.

Clients HTTP avec des empreintes correctes

Pour les tâches ne nécessitant pas de rendu JavaScript, les clients HTTP avec des empreintes TLS et HTTP/2 correctes sont plus efficaces. Les bibliothèques curl-impersonate (pour Python — curl_cffi) et tls-client permettent d'imiter les empreintes TLS des navigateurs réels.

from curl_cffi import requests

# Imiter Chrome 120 avec une empreinte TLS et HTTP/2 correcte
response = requests.get(
    'https://example.com',
    impersonate="chrome120",
    proxies={
        "http": "http://user:pass@proxy:port",
        "https": "http://user:pass@proxy:port"
    },
    headers={
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br',
        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"'
    }
)

# L'empreinte TLS correspond automatiquement à Chrome 120

Techniques d'automatisation sans déclencheurs de détection

Même avec une empreinte technique parfaite, les modèles d'automatisation peuvent révéler un bot. Il est nécessaire d'imiter le comportement humain au niveau de l'interaction avec le site.

Émulation des mouvements de la souris

Un mouvement rectiligne de la souris du point A au point B est un signe évident d'automatisation. La main humaine crée des courbes fluides avec des micro-corrections. Des bibliothèques comme pyautogui permettent de générer des trajectoires réalistes en utilisant des courbes de Bézier.

// Génération d'une trajectoire de souris humaine
async function humanMouseMove(page, targetX, targetY) {
  const current = await page.evaluate(() => ({
    x: window.mouseX || 0,
    y: window.mouseY || 0
  }));
  
  const steps = 25 + Math.floor(Math.random() * 15);
  const points = generateBezierCurve(current.x, current.y, targetX, targetY, steps);
  
  for (let point of points) {
    await page.mouse.move(point.x, point.y);
    await new Promise(r => setTimeout(r, 10 + Math.random() * 20));
  }
  
  // Micro-corrections avant le clic
  await page.mouse.move(targetX + (Math.random() - 0.5) * 2, 
                        targetY + (Math.random() - 0.5) * 2);
}

function generateBezierCurve(x1, y1, x2, y2, steps) {
  const cp1x = x1 + (x2 - x1) * (0.3 + Math.random() * 0.2);
  const cp1y = y1 + (y2 - y1) * (0.3 + Math.random() * 0.2);
  const points = [];
  
  for (let i = 0; i <= steps; i++) {
    const t = i / steps;
    const x = Math.pow(1-t, 2) * x1 + 2 * (1-t) * t * cp1x + Math.pow(t, 2) * x2;
    const y = Math.pow(1-t, 2) * y1 + 2 * (1-t) * t * cp1y + Math.pow(t, 2) * y2;
    points.push({x: Math.round(x), y: Math.round(y)});
  }
  return points;
}

Défilement réaliste et lecture de contenu

Un humain fait défiler la page pour lire le contenu, s'arrêtant sur des sections intéressantes. Un bot fait généralement défiler jusqu'en bas de la page ou jusqu'à l'élément souhaité aussi rapidement que possible. L'imitation de la lecture nécessite une analyse du contenu et la création de pauses réalistes.

async function humanScroll(page, targetElement) {
  const elementPosition = await page.evaluate(el => {
    const rect = el.getBoundingClientRect();
    return rect.top + window.pageYOffset;
  }, targetElement);
  
  const currentScroll = await page.evaluate(() => window.pageYOffset);
  const distance = elementPosition - currentScroll;
  const scrollSteps = Math.floor(Math.abs(distance) / 100);
  
  for (let i = 0; i < scrollSteps; i++) {
    const scrollAmount = (distance / scrollSteps) * (0.8 + Math.random() * 0.4);
    await page.evaluate((amount) => {
      window.scrollBy({top: amount, behavior: 'smooth'});
    }, scrollAmount);
    
    // Pauses aléatoires pour "lecture"
    if (Math.random() > 0.7) {
      await new Promise(r => setTimeout(r, 1000 + Math.random() * 2000));
    } else {
      await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
    }
  }
}

Modèles de navigation naturels

Les utilisateurs ne vont pas directement à la page cible — ils interagissent avec le site de manière naturelle. Commencez par la page d'accueil, visitez plusieurs sections, utilisez la recherche ou le menu de navigation. Cela crée un historique d'interaction qui augmente la confiance des systèmes de protection.

Il est également important d'imiter les erreurs et les corrections — un humain peut cliquer sur le mauvais lien et revenir en arrière, faire une erreur en saisissant dans le champ de recherche et corriger une faute de frappe. Un chemin idéalement direct vers l'objectif semble suspect.

Gestion des cookies et du stockage

PerimeterX et Akamai utilisent des cookies et localStorage pour suivre les sessions. Un nettoyage complet des cookies entre les requêtes semble suspect — un véritable navigateur conserve certains cookies (analytique, paramètres). Conservez les cookies entre les sessions pour un "utilisateur", mais utilisez des ensembles de cookies différents pour différents profils.

Cas pratiques et solutions aux problèmes typiques

Examinons des scénarios spécifiques de contournement de PerimeterX et Akamai avec des solutions aux problèmes typiques rencontrés lors du processus.

Cas 1 : Extraction de données e-commerce avec PerimeterX

Tâche : extraction de données sur les produits d'un grand site de commerce électronique protégé par PerimeterX. Le site bloque après 3-5 requêtes même avec des IP différentes.

Solution : Utilisation d'une combinaison de proxies résidentiels avec des sessions collantes (30 minutes) et Playwright avec une émulation complète du comportement. Points clés : commencer par la page d'accueil, utiliser la recherche ou les catégories pour naviguer, ajouter des délais aléatoires de 3 à 7 secondes entre les requêtes, imiter le défilement et les mouvements de la souris. Critique — conserver les cookies _px entre les requêtes dans le cadre d'une même session.

// Exemple de session avec réchauffement
async function scrapeWithWarmup(page, targetUrls) {
  // Réchauffement du profil
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navigation via le menu
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Ce n'est qu'après le réchauffement que nous passons aux pages cibles
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Extraction des données
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Cas 2 : Contournement d'Akamai pour les requêtes API

Tâche : accès à une API protégée par Akamai Bot Manager. L'API nécessite des en-têtes spécifiques et des jetons générés par JavaScript sur la page.

Solution : Akamai utilise souvent sensor_data — une chaîne chiffrée avec les résultats des vérifications du navigateur. Cette chaîne est générée par JavaScript et doit être incluse dans la requête. Utilisez l'automatisation du navigateur pour obtenir un sensor_data valide, puis appliquez-le dans un client HTTP avec une empreinte TLS correcte.

// Extraction de sensor_data via le navigateur
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Attendre l'exécution du capteur Akamai
  await page.waitForTimeout(5000);
  
  // Extraire sensor_data des cookies ou du localStorage
  const sensorData = await page.evaluate(() => {
    const cookie = document.cookie.split(';')
      .find(c => c.trim().startsWith('_abck='));
    return cookie ? cookie.split('=')[1] : null;
  });
  
  return sensorData;
}

// Utilisation dans le client HTTP
const sensorData = await getSensorData(page);
const response = await fetch('https://example.com/api/data', {
  headers: {
    'Cookie': `_abck=${sensorData}`,
    'User-Agent': 'Mozilla/5.0...',
    // Les autres en-têtes doivent correspondre au navigateur
  }
});

Cas 3 : Résolution de CAPTCHA et pages challenge

Problème : même avec une configuration correcte, PerimeterX ou Akamai affichent parfois des pages challenge ou des CAPTCHA pour une vérification supplémentaire.

Solution : Les pages challenge de PerimeterX effectuent généralement des vérifications supplémentaires...