Comment éviter la détection de l'automatisation par des attaques par temporisation : protection dans Selenium et Puppeteer

Les attaques de timing sont une méthode de détection des bots basée sur l'analyse du temps d'exécution des actions dans le navigateur. Les systèmes anti-fraude modernes de Facebook, Google, TikTok et d'autres plateformes analysent non seulement ce que vous faites, mais aussi à quelle vitesse. Des clics trop rapides, un chargement instantané des pages, l'absence de pauses naturelles — tout cela révèle l'automatisation. Dans cet article, nous examinerons les méthodes techniques de protection contre les attaques de timing pour les développeurs travaillant avec Selenium, Puppeteer et les navigateurs anti-détection.

Qu'est-ce que les attaques de timing et comment fonctionnent-elles

Une attaque de timing est une méthode de détection de l'automatisation basée sur la mesure des intervalles de temps entre les actions de l'utilisateur. Les systèmes anti-fraude collectent des données de télémétrie : combien de temps s'est écoulé entre le chargement de la page et le premier clic, à quelle vitesse l'utilisateur fait défiler, s'il y a des pauses lors du remplissage des formulaires. Ces données sont comparées aux modèles comportementaux des vraies personnes.

Les principales métriques temporelles que les systèmes de protection analysent :

• Time to First Interaction (TTFI) — temps écoulé entre le chargement de la page et la première action (clic, défilement, saisie de texte). Les bots agissent généralement instantanément après le chargement du DOM, un humain — après 0,5 à 3 secondes.
• Modèles de timing des clics — intervalles entre les clics. Les scripts automatisés cliquent souvent à une fréquence constante (par exemple, exactement toutes les 2 secondes), un humain — de manière chaotique.
• Consistance de la vitesse de frappe — vitesse de saisie. Les bots saisissent le texte instantanément ou avec un délai constant entre les caractères, un humain — avec une vitesse variable et des pauses.
• Vitesse de mouvement de la souris — vitesse de déplacement du curseur. Selenium téléporte par défaut instantanément le curseur au bon endroit, un humain déplace la souris avec accélération et décélération.
• Comportement de défilement — modèles de défilement de la page. Les bots défilent souvent exactement d'un nombre fixe de pixels, un humain — de manière inégale, avec des arrêts.

Les systèmes de détection utilisent l'apprentissage automatique pour analyser ces métriques. Ils construisent un profil comportemental et calculent la probabilité que l'utilisateur soit un bot. Si les modèles temporels sont trop parfaits ou trop rapides — c'est un signal d'alerte.

Méthodes de détection de l'automatisation par des modèles temporels

Les systèmes anti-fraude modernes utilisent plusieurs couches d'analyse des caractéristiques temporelles. Examinons des techniques spécifiques utilisées par Facebook, Google, Cloudflare et d'autres plateformes.

1. Analyse de l'API Performance

Les navigateurs fournissent une API Performance qui collecte des données de télémétrie détaillées sur le chargement de la page. Les systèmes anti-fraude analysent :

// Exemple de données de l'API Performance
performance.timing = {
  navigationStart: 1234567890000,
  domLoading: 1234567890150,      // +150ms
  domInteractive: 1234567890300,  // +300ms
  domComplete: 1234567890500,     // +500ms
  loadEventEnd: 1234567890600     // +600ms
}

// Modèles suspects pour les bots :
// - Chargement trop rapide (domComplete < 200ms)
// - Intervalles parfaitement réguliers entre les événements
// - Absence de délais pour le chargement des ressources externes

Les navigateurs headless (en particulier les anciennes versions de Puppeteer et Selenium) montrent souvent des valeurs anormalement rapides pour navigationStart et domLoading, car ils ne chargent pas les images, les polices et d'autres ressources de la même manière qu'un navigateur normal.

2. Analyse du timing des événements

Les trackers JavaScript suivent les timestamps de tous les événements (clics, mouvements de souris, frappes) et analysent les modèles :

// Exemple de collecte de télémétrie des événements
const events = [];

document.addEventListener('click', (e) => {
  events.push({
    type: 'click',
    timestamp: performance.now(),
    x: e.clientX,
    y: e.clientY
  });
});

// Analyse des modèles suspects :
// - Les clics se produisent exactement toutes les N millisecondes
// - Pas de micro-mouvements de la souris avant le clic
// - Le premier clic se produit instantanément après le chargement de la page

3. Dynamiques de frappe

Lors du remplissage des formulaires, les systèmes anti-fraude analysent la dynamique des frappes — un indicateur biométrique unique pour chaque personne :

• Dwell time — temps de maintien de la touche (de keydown à keyup). Pour un humain, cela varie de 50 à 200 ms, pour les bots — c'est constant.
• Flight time — temps entre le relâchement d'une touche et l'appui sur la suivante. Pour un humain — de 100 à 500 ms avec des variations, pour les bots — un délai fixe.
• Rythme de frappe — rythme global de la saisie. Un humain fait des pauses sur les signes de ponctuation, corrige des erreurs, les bots — non.

Imitation des délais humains dans le code

Le premier niveau de protection contre les attaques de timing consiste à ajouter des délais entre les actions. Mais il est important de ne pas simplement insérer time.sleep(2), mais d'imiter un comportement naturel.

Imitation de base des délais en Python (Selenium)

import time
import random
from selenium import webdriver
from selenium.webdriver.common.by import By

def human_delay(min_sec=0.5, max_sec=2.0):
    """Délai aléatoire imitant un humain"""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

driver = webdriver.Chrome()
driver.get("https://example.com")

# Délai avant la première action (un humain lit la page)
human_delay(1.5, 4.0)

# Clic sur l'élément
button = driver.find_element(By.ID, "submit-btn")
button.click()

# Délai avant l'action suivante
human_delay(0.8, 2.5)

Imitation avancée avec distribution normale

Une distribution uniforme (uniform) semble peu naturelle. Les délais humains suivent une distribution normale avec des valeurs aberrantes :

import numpy as np

def realistic_delay(mean=1.5, std_dev=0.5, min_val=0.3, max_val=5.0):
    """
    Délai avec distribution normale
    mean: temps moyen de délai
    std_dev: écart type
    min_val, max_val: limites (pour éviter des valeurs extrêmes)
    """
    delay = np.random.normal(mean, std_dev)
    delay = max(min_val, min(max_val, delay))  # Limiter la plage
    time.sleep(delay)
    return delay

# Utilisation
realistic_delay(mean=2.0, std_dev=0.7)  # Moyenne de 2 secondes, mais avec des variations

Délai contextuel

Différentes actions nécessitent des temps différents. Créez des profils de délais pour différents scénarios :

class HumanBehavior:
    """Profils de délais pour différents types d'actions"""
    
    @staticmethod
    def page_load_delay():
        """Délai après le chargement de la page (lecture du contenu)"""
        return realistic_delay(mean=2.5, std_dev=1.0, min_val=1.0, max_val=6.0)
    
    @staticmethod
    def before_click():
        """Délai avant le clic (recherche de l'élément avec les yeux)"""
        return realistic_delay(mean=0.8, std_dev=0.3, min_val=0.3, max_val=2.0)
    
    @staticmethod
    def before_typing():
        """Délai avant de commencer à saisir du texte"""
        return realistic_delay(mean=1.2, std_dev=0.5, min_val=0.5, max_val=3.0)
    
    @staticmethod
    def between_form_fields():
        """Délai entre les champs du formulaire"""
        return realistic_delay(mean=0.6, std_dev=0.2, min_val=0.2, max_val=1.5)

# Utilisation dans le script
driver.get("https://example.com/login")
HumanBehavior.page_load_delay()

username_field = driver.find_element(By.ID, "username")
HumanBehavior.before_typing()
# ... saisie du nom d'utilisateur ...

HumanBehavior.between_form_fields()

password_field = driver.find_element(By.ID, "password")
HumanBehavior.before_typing()
# ... saisie du mot de passe ...

Randomisation du temps d'exécution des actions

Des délais identiques entre les actions constituent une anomalie statistique. Si vous exécutez 100 instances du script, et que toutes cliquent sur le bouton exactement 2,5 secondes après le chargement — cela est facilement détecté. Une randomisation à plusieurs niveaux est nécessaire.

1. Randomisation de l'ordre des actions

Ajoutez de la variabilité à la séquence des actions. Par exemple, avant de remplir un formulaire, faites parfois défiler la page, parfois non :

def fill_form_naturally(driver):
    # 30% de probabilité de faire défiler la page avant de remplir
    if random.random() < 0.3:
        driver.execute_script("window.scrollBy(0, 200)")
        human_delay(0.5, 1.5)
    
    # 20% de probabilité de cliquer à un endroit aléatoire (imitation de la lecture)
    if random.random() < 0.2:
        body = driver.find_element(By.TAG_NAME, "body")
        body.click()
        human_delay(0.3, 0.8)
    
    # Action principale — remplissage du formulaire
    username_field = driver.find_element(By.ID, "username")
    type_like_human(username_field, "monnomdutilisateur")

2. Vitesse de saisie variable

Au lieu d'une saisie instantanée, imitez une saisie caractère par caractère avec une vitesse variable :

def type_like_human(element, text):
    """Saisie de texte en imitant la vitesse de frappe humaine"""
    for char in text:
        element.send_keys(char)
        
        # Délai de base entre les caractères
        base_delay = random.uniform(0.05, 0.15)
        
        # Pauses supplémentaires sur les espaces et les signes de ponctuation
        if char in [' ', '.', ',', '!', '?']:
            base_delay += random.uniform(0.1, 0.3)
        
        # "Réflexions" aléatoires (5% de probabilité d'une longue pause)
        if random.random() < 0.05:
            base_delay += random.uniform(0.5, 1.5)
        
        time.sleep(base_delay)
    
    # Parfois, nous faisons une faute de frappe et corrigeons (10% de probabilité)
    if random.random() < 0.1:
        time.sleep(random.uniform(0.2, 0.5))
        element.send_keys(Keys.BACKSPACE)
        time.sleep(random.uniform(0.1, 0.3))
        element.send_keys(text[-1])  # Saisir à nouveau le dernier caractère

3. Puppeteer : saisie lente de texte

Dans Puppeteer, il existe une option intégrée delay pour la méthode type(), mais elle doit être randomisée :

// Utilisation de base (NON recommandé — délai fixe)
await page.type('#username', 'monnomdutilisateur', { delay: 100 });

// Approche correcte — randomisation pour chaque caractère
async function typeWithVariableSpeed(page, selector, text) {
  await page.click(selector);
  
  for (const char of text) {
    await page.keyboard.type(char);
    
    // Délai aléatoire de 50 à 150 ms
    let delay = Math.random() * 100 + 50;
    
    // Pause supplémentaire sur les espaces
    if (char === ' ') {
      delay += Math.random() * 200 + 100;
    }
    
    // Pauses longues aléatoires (5% de probabilité)
    if (Math.random() < 0.05) {
      delay += Math.random() * 1000 + 500;
    }
    
    await page.waitForTimeout(delay);
  }
}

// Utilisation
await typeWithVariableSpeed(page, '#username', 'monnomdutilisateur');

Mouvement naturel de la souris et vitesse de défilement

Selenium et Puppeteer ne déplacent pas par défaut le curseur de la souris — ils le téléportent instantanément au bon endroit et cliquent. C'est l'un des signes les plus évidents d'automatisation. Pour imiter le mouvement humain de la souris, des bibliothèques spéciales sont nécessaires.

Bibliothèque pyautogui pour un mouvement fluide de la souris

La bibliothèque pyautogui permet de déplacer le curseur le long d'une courbe de Bézier avec accélération et décélération :

import pyautogui
from selenium.webdriver.common.action_chains import ActionChains

def move_mouse_naturally(driver, element):
    """Mouvement fluide de la souris vers l'élément en imitant un humain"""
    # Obtenez les coordonnées de l'élément
    location = element.location
    size = element.size
    
    # Point cible (centre de l'élément + petite variabilité)
    target_x = location['x'] + size['width'] / 2 + random.randint(-5, 5)
    target_y = location['y'] + size['height'] / 2 + random.randint(-5, 5)
    
    # Mouvement fluide avec vitesse variable
    # duration — temps de mouvement (0.5-1.5 sec pour le réalisme)
    duration = random.uniform(0.5, 1.5)
    
    # tweening — fonction d'accélération (easeInOutQuad imite le mouvement humain)
    pyautogui.moveTo(target_x, target_y, duration=duration, tween=pyautogui.easeInOutQuad)
    
    # Petite pause avant le clic (un humain ne clique pas instantanément)
    time.sleep(random.uniform(0.05, 0.15))
    
    # Clic
    element.click()

Important : Cette méthode ne fonctionne que si Selenium contrôle une fenêtre de navigateur réelle (pas en mode headless). Pour le mode headless, le mouvement de la souris est inutile, car les systèmes anti-fraude ne voient pas le curseur.

Puppeteer : imitation du mouvement de la souris

Dans Puppeteer, vous pouvez utiliser la bibliothèque ghost-cursor pour un mouvement réaliste du curseur :

// Installation : npm install ghost-cursor
const { createCursor } = require("ghost-cursor");
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();
  const cursor = createCursor(page);
  
  await page.goto("https://example.com");
  
  // Mouvement fluide vers l'élément et clic
  const button = await page.$("#submit-btn");
  await cursor.click(button);  // Le curseur se déplace le long d'une courbe de Bézier !
  
  // Alternativement — mouvement vers des coordonnées
  await cursor.move("#username");  // Déplacez simplement le curseur sans cliquer
  await page.waitForTimeout(300);
  await cursor.click();  // Cliquez à la position actuelle
})();

Imitation du défilement

Un humain ne fait pas défiler la page exactement de 500 pixels à la fois. Le défilement doit être inégal, avec des pauses et parfois un défilement en arrière :

def scroll_like_human(driver, target_position=None):
    """
    Imitation du défilement humain
    target_position: position cible en pixels (si None — défilez jusqu'à la fin)
    """
    current_position = driver.execute_script("return window.pageYOffset;")
    
    if target_position is None:
        # Défilez jusqu'à la fin de la page
        target_position = driver.execute_script("return document.body.scrollHeight;")
    
    while current_position < target_position:
        # Étape de défilement aléatoire (100-400 pixels)
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        # Défilez
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Pause entre les défilements (un humain lit le contenu)
        time.sleep(random.uniform(0.3, 1.2))
        
        # Parfois, faites défiler un peu en arrière (10% de probabilité)
        if random.random() < 0.1:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.2, 0.6))

# Utilisation
scroll_like_human(driver, target_position=2000)  # Défilez jusqu'à 2000px

Temps de chargement des pages et des requêtes AJAX

Les systèmes anti-fraude analysent non seulement les actions de l'utilisateur, mais aussi les caractéristiques de chargement des pages. Les navigateurs headless se chargent souvent de manière anormalement rapide, car ils ne chargent pas les images, n'exécutent pas certains scripts, ne rendent pas le CSS.

Problème : chargement trop rapide

Comparez les valeurs typiques de l'API Performance pour un navigateur normal et headless :

Solution : délai de chargement forcé

Ajoutez un délai artificiel après le chargement de la page pour que les métriques semblent plus naturelles :

def load_page_naturally(driver, url):
    """Chargement de la page en imitant un temps de chargement naturel"""
    start_time = time.time()
    driver.get(url)
    
    # Attendre le chargement complet du DOM
    WebDriverWait(driver, 10).until(
        lambda d: d.execute_script("return document.readyState") == "complete"
    )
    
    # Calculer le temps de chargement réel
    actual_load_time = time.time() - start_time
    
    # Si le chargement était trop rapide (< 1 sec), ajoutez un délai
    if actual_load_time < 1.0:
        additional_delay = random.uniform(1.0, 2.5) - actual_load_time
        time.sleep(additional_delay)
    
    # Délai supplémentaire pour "lire la page"
    time.sleep(random.uniform(0.5, 2.0))

# Utilisation
load_page_naturally(driver, "https://example.com")

Attente des requêtes AJAX

Les sites modernes chargent le contenu de manière asynchrone via AJAX. Si votre script commence à agir avant que toutes les requêtes AJAX soient terminées — c'est suspect. Utilisez des attentes explicites :

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def wait_for_ajax(driver, timeout=10):
    """Attendre la fin de toutes les requêtes AJAX (jQuery)"""
    WebDriverWait(driver, timeout).until(
        lambda d: d.execute_script("return jQuery.active == 0")
    )

# Pour les sites sans jQuery — attente d'un élément spécifique
def wait_for_dynamic_content(driver, selector, timeout=10):
    """Attendre l'apparition d'un élément chargé dynamiquement"""
    WebDriverWait(driver, timeout).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
    )
    # Délai supplémentaire après l'apparition de l'élément
    time.sleep(random.uniform(0.3, 0.8))

Configuration de la protection dans les navigateurs anti-détection

Si vous travaillez avec l'arbitrage, le multi-comptes ou d'autres tâches où l'anonymat est crucial, utilisez des navigateurs anti-détection : Dolphin Anty, AdsPower, Multilogin, GoLogin. Ils ont des mécanismes de protection intégrés contre les attaques de timing, mais ils doivent être correctement configurés.

Dolphin Anty : configuration de la saisie humaine

Dans Dolphin Anty, il existe une fonction "Human Typing" — imitation automatique de la saisie humaine. Configuration :

• Ouvrez le profil du navigateur → onglet "Automation"
• Activez "Human Typing Emulation"
• Configurez les paramètres :
  • Vitesse de frappe moyenne : 150-250 caractères/minute (vitesse réaliste)
  • Variation : 30-50% (écart de vitesse entre les caractères)
  • Pause sur la ponctuation : activé (pauses sur les signes de ponctuation)
  • Fautes de frappe aléatoires : 2-5% (fautes de frappe aléatoires avec correction)

Après cela, toute saisie de texte via l'API Dolphin imitera automatiquement un humain.

AdsPower : configuration du mouvement de la souris

AdsPower permet d'enregistrer les modèles de mouvement de la souris d'un utilisateur réel et de les reproduire :

1. Ouvrez le profil → "Advanced Settings" → "Mouse Behavior"
2. Sélectionnez le mode "Record Real User":
   • Ouvrez le navigateur en mode normal
   • Effectuez des actions typiques (clics, défilement, mouvements de souris)
   • AdsPower enregistrera les trajectoires de mouvement
3. Lors de l'automatisation via l'API, AdsPower reproduira les modèles enregistrés avec des variations

Multilogin : Canvas Noise et WebGL Timing

Multilogin ajoute du bruit (noise) dans les empreintes Canvas et WebGL, ce qui influence les attaques de timing liées au rendu :

• Profil → "Fingerprint settings" → "Canvas"
• Activez "Canvas Noise" (ajoute des micro-délai dans le rendu Canvas)
• Activez "WebGL Metadata Masking" (masque les caractéristiques GPU, influençant la vitesse de rendu)

Cela protège contre la détection par l'analyse du temps d'exécution de Canvas.toDataURL() et des opérations WebGL.

Techniques avancées pour contourner la détection de timing

Pour les plateformes particulièrement protégées (Google, Facebook, sites bancaires), les méthodes de base peuvent ne pas suffire. Examinons les techniques avancées.

1. Substitution de l'API Performance

Il est possible de redéfinir les méthodes de l'API Performance pour renvoyer des valeurs réalistes au lieu des réelles :

// Injection de script pour remplacer performance.now()
const script = `
  (function() {
    const originalNow = performance.now.bind(performance);
    let offset = 0;
    let lastValue = 0;
    
    performance.now = function() {
      const realValue = originalNow();
      // Ajout d'un bruit aléatoire au temps
      const noise = Math.random() * 2 - 1; // de -1 à +1 ms
      let fakeValue = realValue + offset + noise;
      
      // Garantir la monotonie (le temps ne recule pas)
      if (fakeValue <= lastValue) {
        fakeValue = lastValue + 0.1;
      }
      
      lastValue = fakeValue;
      return fakeValue;
    };
  })();
`;

// Puppeteer : injection lors de la création de la page
await page.evaluateOnNewDocument(script);

Attention : Cette méthode peut être détectée par la vérification de l'intégrité des méthodes natives. Utilisez-la uniquement sur des sites sans protection forte.

2. Limitation du CPU et du réseau

Le protocole Chrome DevTools permet de ralentir artificiellement le CPU et le réseau pour que les métriques de chargement semblent plus naturelles :

// Puppeteer : ralentissement du CPU par 2
const client = await page.target().createCDPSession();
await client.send('Emulation.setCPUThrottlingRate', { rate: 2 });

// Ralentissement du réseau (émulation 3G)
await page.emulateNetworkConditions({
  offline: false,
  downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
  uploadThroughput: 750 * 1024 / 8,          // 750 Kbps
  latency: 40                                 // 40ms de latence
});

Cela augmentera le temps de chargement des pages et l'exécution de JavaScript, rendant le profil plus semblable à celui d'un utilisateur réel avec une vitesse Internet moyenne.

3. Imitation de l'activité en arrière-plan

Les utilisateurs réels ne restent pas sur un seul onglet — ils passent d'un onglet à l'autre, minimisent des fenêtres, se laissent distraire. Imitez cela :

async function simulateTabSwitch(page) {
  // Émuler le changement vers un autre onglet (Page Visibility API)
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => true,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
  
  // Pause (l'utilisateur regarde un autre onglet)
  await page.waitForTimeout(Math.random() * 3000 + 2000);
  
  // Retour à l'onglet
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => false,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
}

// Utilisation : "se distraire" aléatoirement pendant le travail
if (Math.random() < 0.15) {  // 15% de probabilité
  await simulateTabSwitch(page);
}

4. Utilisation de véritables User Timing marks

Certains sites créent leurs propres timestamps via l'API User Timing. Ajoutez des timestamps réalistes :

// Création de timestamps réalistes
await page.evaluate(() => {
  // Imitation de la "réflexion" de l'utilisateur avant l'action
  performance.mark('user-started-reading');
  
  setTimeout(() => {
    performance.mark('user-found-button');
    performance.measure('reading-time', 'user-started-reading', 'user-found-button');
  }, Math.random() * 2000 + 1000);
});

5. Rotation des proxies pour réduire la corrélation statistique

Même si chaque instance de votre script a des délais randomisés, les systèmes anti-fraude peuvent détecter une corrélation si toutes les requêtes proviennent d'une seule IP. Utilisez la rotation des proxies :

• Pour le scraping et les tâches massives : proxies de centre de données avec rotation automatique toutes les 5-10 minutes
• Pour les réseaux sociaux et la publicité : proxies résidentiels avec liaison de session (sticky sessions)
• Pour les plateformes mobiles (Instagram, TikTok) : proxies mobiles avec rotation par minuteur ou à la demande

La rotation des IP réduit la probabilité que le système anti-fraude puisse rassembler suffisamment de données pour une analyse statistique de vos modèles de timing.

Conclusion

Les attaques de timing sont une méthode complexe de détection de l'automatisation qui nécessite une approche globale de protection. Principales conclusions :

• Ne pas utiliser de délais fixes — randomisez toujours le temps entre les actions en utilisant une distribution normale
• Imitez les délais contextuels — différentes actions nécessitent des temps différents (lecture de la page ≠ clic sur un bouton)
• Ajoutez de la variabilité à la séquence des actions — défilements, clics, changements d'onglets aléatoires
• Utilisez un mouvement fluide de la souris — bibliothèques ghost-cursor (Puppeteer) ou pyautogui (Selenium)
• Imitez une vitesse de saisie naturelle — saisie caractère par caractère avec des pauses sur les signes de ponctuation
• Configurez les navigateurs anti-détection — Dolphin Anty, AdsPower et Multilogin ont des mécanismes de protection intégrés contre les attaques de timing
• Combinez avec des proxies de qualité — la rotation des IP réduit la possibilité d'analyse statistique

Rappelez-vous : il n'existe pas de protection parfaite. Les systèmes anti-fraude évoluent constamment, ajoutant de nouvelles méthodes de détection. Votre tâche est de rapprocher au maximum le comportement du script de celui d'un utilisateur réel et de mettre régulièrement à jour les méthodes de contournement.

Si vous travaillez avec l'automatisation des navigateurs pour le scraping, les tests ou d'autres tâches, nous vous recommandons d'utiliser des proxies résidentiels — ils offrent le niveau d'anonymat maximal et minimisent le risque de détection par adresse IP. Pour les plateformes mobiles, les proxies mobiles sont plus adaptés, car ils imitent les utilisateurs réels des opérateurs mobiles.