Comment éviter les blocages Google lors du scraping SERP

Comment Google détecte les gratte-ciel SERP

Google investit fortement dans la protection de ses résultats de recherche de l'accès automatisé. Avant de pouvoir éviter les blocs, vous devez comprendre les méthodes de détection que Google emploie. Chaque méthode vise un signal différent, et le grattage efficace du SERP nécessite de les traiter tous simultanément.

Pour un aperçu complet de l'architecture de grattage SERP avec proxies, consultez notre SERP raclage avec guide proxies.

Détection par IP

La première ligne de défense est l'analyse IP. Google suit le volume de requête par adresse IP et les drapeaux qui dépassent les modèles de recherche humaine normaux. Les signaux spécifiques comprennent:

• Fréquence de demande: Plus de quelques recherches par minute à partir d'une seule IP déclenche la limitation du taux
• La réputation de la PI : Les plages IP connues des datacenter sont immédiatement examinées
• Incohérence géographique : Une IP d'Allemagne faisant des requêtes ciblées par les États-Unis en anglais soulève des drapeaux
• Analyse ASN: Google identifie les blocs IP appartenant aux fournisseurs d'hébergement par rapport aux FSI

Empreinte digitale du navigateur

Au-delà des adresses IP, Google examine la demande elle-même des signes d'automatisation:

Pour un examen plus approfondi de ces techniques, lisez notre article sur comment les systèmes anti-bot détectent les proxies.

Analyse comportementale

Google analyse les modèles parmi les demandes pour détecter l'automatisation:

• Calendrier de la demande: Des intervalles parfaitement cohérents entre les demandes (ex.: exactement 3 secondes d'intervalle) sont contre nature
• Modèles de requête: Scraping mots clés alphabétiquement ou dans des séquences prévisibles semble automatisé
• Comportement de la séance : Les utilisateurs réels parcourent plusieurs pages, cliquent sur les résultats et passent du temps à lire — les grattoirs récupèrent simplement les SERP
• Modèles de volume: Des pics soudains dans le volume de la requête à partir des IP connexes suggèrent un grattage coordonné

Les trois couches de la stratégie antiblocage

Éviter les blocs Google nécessite une approche en couches. Aucune technique ne suffit à elle seule.

Couche 1: Infrastructure mandataire

Votre choix de mandataire est le fondement de votre stratégie antiblocage. ProxyHat proxies résidentielles fournir la diversité de la propriété intellectuelle et le niveau de confiance nécessaire à la mise au rebut durable du SERP.

Calque 2: Configuration de la requête

Chaque requête HTTP doit ressembler à celle d'un vrai navigateur. Les en-têtes, les cookies et le timing doivent tous être réalistes.

Calque 3 : Modèles comportementaux

Le modèle global de votre activité de grattage doit imiter le comportement de recherche naturelle. Cela signifie des retards randomisés, des séquences de requêtes variées et des volumes de requêtes appropriés.

Proxies résidentielles : votre première défense

Le changement le plus important que vous pouvez faire est de passer de datacenter à Proxies résidentielles. Voici pourquoi les IP résidentielles sont fondamentalement différentes du point de vue de Google:

• Les IP résidentielles appartiennent à de vrais FAI (Comcast, AT&T, BT, Deutsche Telekom), non aux fournisseurs de cloud
• Google ne peut pas bloquer les plages IP résidentielles sans bloquer les utilisateurs légitimes
• Chaque IP a une histoire de navigation et une réputation construite par son utilisateur réel
• Les IP résidentielles soutiennent le géo-ciblage au niveau de la ville pour les PEEE localisés

Configuration de proxy pour le scraping SERP

import requests
# ProxyHat residential proxy with automatic rotation
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
session = requests.Session()
session.proxies = {
    "http": PROXY_URL,
    "https": PROXY_URL,
}
# Each request automatically gets a new residential IP
response = session.get(
    "https://www.google.com/search",
    params={"q": "best proxy service", "num": 10, "hl": "en", "gl": "us"},
    headers={
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "DNT": "1",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
    },
    timeout=15,
)

Voir Documentation ProxyHat pour la rotation avancée et les réglages de session.

En-têtes de demande réaliste

Les en-têtes incomplets ou incohérents sont l'une des raisons les plus courantes pour lesquelles les racleurs sont bloqués. Voici un ensemble d'en-têtes complet et réaliste:

import random
# Rotate between realistic User-Agent strings
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15",
]
def get_headers():
    ua = random.choice(USER_AGENTS)
    headers = {
        "User-Agent": ua,
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "DNT": "1",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-User": "?1",
        "Cache-Control": "max-age=0",
    }
    # Firefox has different Sec-Ch headers
    if "Firefox" not in ua:
        headers["Sec-Ch-Ua"] = '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"'
        headers["Sec-Ch-Ua-Mobile"] = "?0"
        headers["Sec-Ch-Ua-Platform"] = '"Windows"' if "Windows" in ua else '"macOS"'
    return headers

Gardez toujours vos chaînes User-Agent à jour avec les versions actuelles du navigateur. Envoyer un Chrome 90 User-Agent en 2026 est un drapeau rouge immédiat.

Limite tarifaire et calendrier de la demande

La configuration de vos demandes est aussi importante que les demandes elles-mêmes. Voici des stratégies de timing éprouvées :

Délais aléatoires

N'utilisez jamais des intervalles fixes entre les requêtes. Au lieu de cela, randomisez les retards pour imiter le comportement de recherche humaine:

import time
import random
def human_delay():
    """Generate a realistic delay between searches."""
    # Base delay: 3-8 seconds (normal browsing pace)
    base = random.uniform(3, 8)
    # Occasionally add longer pauses (simulating reading results)
    if random.random() < 0.15:
        base += random.uniform(10, 30)
    # Rare very short delays (rapid refinement searches)
    if random.random() < 0.05:
        base = random.uniform(1, 2)
    return base
# Usage in scraping loop
for keyword in keywords:
    result = scrape_serp(keyword)
    delay = human_delay()
    time.sleep(delay)

Demande Volume Lignes directrices

Manipulation des CAPTCHA et des blocs

Même avec les meilleures précautions, vous rencontrerez parfois des blocs. Construisez votre racleur pour les manipuler avec grâce.

Détecter les blocs

def is_blocked(response):
    """Check if Google has blocked or challenged the request."""
    # HTTP 429: Rate limited
    if response.status_code == 429:
        return "rate_limited"
    # HTTP 503: Service unavailable (temporary block)
    if response.status_code == 503:
        return "service_unavailable"
    text = response.text.lower()
    # CAPTCHA detection
    if "captcha" in text or "recaptcha" in text:
        return "captcha"
    # Unusual traffic message
    if "unusual traffic" in text or "automated queries" in text:
        return "unusual_traffic"
    # Empty or suspicious results
    if "did not match any documents" in text and len(text) < 5000:
        return "empty_suspicious"
    return None

Stratégie de réessayer

import time
import random
def scrape_with_retry(keyword, max_retries=3):
    """Scrape a SERP with automatic retry on blocks."""
    for attempt in range(max_retries):
        proxy_url = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
        proxies = {"http": proxy_url, "https": proxy_url}
        response = requests.get(
            "https://www.google.com/search",
            params={"q": keyword, "num": 10, "hl": "en", "gl": "us"},
            headers=get_headers(),
            proxies=proxies,
            timeout=15,
        )
        block_type = is_blocked(response)
        if block_type is None:
            return parse_results(response.text)
        if block_type == "rate_limited":
            # Exponential backoff
            wait = (2 ** attempt) * 5 + random.uniform(0, 5)
            print(f"Rate limited. Waiting {wait:.1f}s (attempt {attempt + 1})")
            time.sleep(wait)
        elif block_type == "captcha":
            # Switch to a new IP and wait
            print(f"CAPTCHA detected. Rotating IP and waiting...")
            time.sleep(random.uniform(10, 20))
        else:
            # Generic block: wait and retry
            time.sleep(random.uniform(5, 15))
    return None  # All retries exhausted

Cohérence géographique

Une mesure subtile mais importante contre la détection est d'assurer la cohérence géographique entre les paramètres de votre demande :

• Si votre IP proxy est aux États-Unis, définissez gl=us et hl=en
• Correspondez à l'en-tête Accept-Language à la localité cible
• Utilisez une chaîne User-Agent pour une combinaison OS/browser commune dans ce pays
• Réglez les heures de demande appropriées au fuseau horaire

Chez ProxyHat fonction de géo-ciblage vous permet de sélectionner des procurations dans des pays et des villes spécifiques, ce qui rend simple de maintenir cette cohérence. En savoir plus sur l'utilisation des demandes ciblées par emplacement dans notre guide sur grattage sans être bloqué.

Node.js Mise en œuvre antiblocage

Voici la stratégie antiblocage équivalente mise en œuvre dans Node.js:

const axios = require('axios');
const cheerio = require('cheerio');
const { HttpsProxyAgent } = require('https-proxy-agent');
const USER_AGENTS = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0',
];
function getRandomUA() {
  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
}
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
async function scrapeWithRetry(keyword, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
    try {
      const { data, status } = await axios.get('https://www.google.com/search', {
        params: { q: keyword, num: 10, hl: 'en', gl: 'us' },
        headers: {
          'User-Agent': getRandomUA(),
          'Accept': 'text/html,application/xhtml+xml',
          'Accept-Language': 'en-US,en;q=0.9',
        },
        httpsAgent: agent,
        timeout: 15000,
        validateStatus: () => true,
      });
      if (status === 429) {
        const wait = Math.pow(2, attempt) * 5000 + Math.random() * 5000;
        console.log(`Rate limited. Waiting ${(wait/1000).toFixed(1)}s`);
        await sleep(wait);
        continue;
      }
      if (data.toLowerCase().includes('captcha')) {
        console.log('CAPTCHA detected. Rotating IP...');
        await sleep(10000 + Math.random() * 10000);
        continue;
      }
      return cheerio.load(data);
    } catch (err) {
      console.log(`Attempt ${attempt + 1} failed: ${err.message}`);
      await sleep(5000 + Math.random() * 10000);
    }
  }
  return null;
}

Techniques avancées

randomisation des requêtes

Ne grattez pas les mots-clés par ordre alphabétique ou séquentiel. Shuffle votre liste de mots clés avant chaque exécution:

import random
keywords = ["proxy service", "web scraping", "serp tracking", "seo tools"]
random.shuffle(keywords)
# Now scrape in random order
for kw in keywords:
    scrape_with_retry(kw)

Paramètres de recherche Google

Utilisez ces paramètres pour obtenir des résultats propres et non personnalisés :

Calendrier distribué

Pour la surveillance SERP à grande échelle, distribuer les demandes dans le temps afin d'éviter les éclatements. Au lieu de gratter 10 000 mots clés en une heure, les répartir sur 8-12 heures avec des courbes de trafic naturel (plus de demandes pendant les heures d'ouverture, moins la nuit).

L'objectif n'est pas seulement d'éviter les blocs — c'est de rendre votre trafic de grattage impossible à distinguer du comportement normal de recherche utilisateur. Chaque détail compte.

Pour en savoir plus sur la construction de conduites de démolition fiables et à grande échelle, consultez notre guide complet sur les proxies de raclage de toile et Solutions de raclage du réseau ProxyHat.