SERP et SEO 9 min de lecture

Comment scraper les résultats de recherche Google avec des proxies

Apprenez comment racler les SERP Google en utilisant des procurations résidentielles. Des exemples complets de code dans Python, Node.js, et Go pour extraire des résultats organiques, ont présenté des extraits, et People Ask également données.

ProxyHat Team
Comment scraper les résultats de recherche Google avec des proxies

Pourquoi Scrape Google résultats de recherche?

Google traite plus de 8,5 milliards de recherches par jour, faisant de ses pages de résultats de moteurs de recherche (SERP) la source la plus précieuse d'intelligence concurrentielle sur le web. Scraping Google résultats de recherche vous donne accès à des classements organiques, a présenté des extraits, People Aussi demander des boîtes, des paquets locaux, et des placements publicitaires payés — tout en temps réel.

Que vous construisiez une Ligne de surveillance SERP ou effectuer une recherche par mot-clé unique, l'accès programmatique aux résultats de Google vous permet d'automatiser les workflows qui prendraient des heures à effectuer manuellement. Les cas d'utilisation courante comprennent:

  • Suivi de vos propres classements de mots clés à travers les marchés
  • Surveillance de la visibilité des concurrents pour les requêtes ciblées
  • Analyser la distribution des fonctionnalités SERP (extraits, images, vidéos)
  • Créer des ensembles de données pour la stratégie de recherche et de contenu en matière d'observations spatiales

Comprendre la structure de Google SERP

Avant d'écrire un grattoir, vous devez comprendre l'anatomie d'une page de résultats Google. Un SERP moderne peut contenir plus d'une douzaine de types de résultats distincts:

Comprendre la structure de Google SERP
Type de résultatCSS / Marqueur de donnéesDésignation des marchandises
Résultats biologiquesdiv#search .gRésultats standard de liaison bleue avec titre, URL et extrait
Extrait de présentationdiv.xpdopenBoîte de réponse affichée au-dessus des résultats biologiques
Les gens aussi s'interrogentdiv.related-question-pairQuestions de type FAQ extensible
Emballage localdiv.VkpGBbCarte avec 3 annonces d'entreprises locales
Groupe de connaissancesdiv.kp-wholepageBarre latérale de l'information de l'entité
Résultats de la publicitédiv.uEierdAnnonces de recherche payantes en haut et en bas
Google change fréquemment de nom de classe. Construisez votre analyseur avec des sélecteurs de recul et testez régulièrement pour garder l'extraction fiable.

Configuration de votre environnement de scraping

Pour racler Google de manière fiable, vous avez besoin de trois composants : un client HTTP, une connexion proxy et un analyseur HTML. Voici des exemples complets dans Python, Node.js et Go en utilisant ProxyHat proxies.

Exemple de Python

Installez d'abord les dépendances. Les ProxyHat Python SDK simplifie la configuration du proxy.

pip install requests beautifulsoup4
import requests
from bs4 import BeautifulSoup
proxy_url = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}
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-Language": "en-US,en;q=0.9",
}
def scrape_google(query, num_results=10):
    params = {
        "q": query,
        "num": num_results,
        "hl": "en",
        "gl": "us",
    }
    response = requests.get(
        "https://www.google.com/search",
        params=params,
        headers=headers,
        proxies=proxies,
        timeout=15,
    )
    response.raise_for_status()
    soup = BeautifulSoup(response.text, "html.parser")
    results = []
    for g in soup.select("div#search .g"):
        title_el = g.select_one("h3")
        link_el = g.select_one("a")
        snippet_el = g.select_one(".VwiC3b")
        if title_el and link_el:
            results.append({
                "title": title_el.get_text(),
                "url": link_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
            })
    return results
results = scrape_google("best residential proxies 2026")
for i, r in enumerate(results, 1):
    print(f"{i}. {r['title']}\n   {r['url']}\n")

Exemple de Node.js

Utilisation ProxyHat Node SDK et Cheerio pour l'analyse:

npm install axios cheerio https-proxy-agent
const axios = require('axios');
const cheerio = require('cheerio');
const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
async function scrapeGoogle(query) {
  const { data } = await axios.get('https://www.google.com/search', {
    params: { q: query, num: 10, hl: 'en', gl: 'us' },
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Accept-Language': 'en-US,en;q=0.9',
    },
    httpsAgent: agent,
    timeout: 15000,
  });
  const $ = cheerio.load(data);
  const results = [];
  $('div#search .g').each((i, el) => {
    const title = $(el).find('h3').text();
    const url = $(el).find('a').attr('href');
    const snippet = $(el).find('.VwiC3b').text();
    if (title && url) {
      results.push({ position: i + 1, title, url, snippet });
    }
  });
  return results;
}
scrapeGoogle('best residential proxies 2026').then(console.log);

Go Exemple

Utilisation ProxyHat Go SDK et goquerie:

package main
import (
    "fmt"
    "log"
    "net/http"
    "net/url"
    "github.com/PuerkitoBio/goquery"
)
func main() {
    proxyURL, _ := url.Parse("http://USERNAME:PASSWORD@gate.proxyhat.com:8080")
    client := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    }
    req, _ := http.NewRequest("GET", "https://www.google.com/search?q=best+residential+proxies&num=10&hl=en&gl=us", nil)
    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
    req.Header.Set("Accept-Language", "en-US,en;q=0.9")
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    doc, _ := goquery.NewDocumentFromReader(resp.Body)
    doc.Find("div#search .g").Each(func(i int, s *goquery.Selection) {
        title := s.Find("h3").Text()
        link, _ := s.Find("a").Attr("href")
        fmt.Printf("%d. %s\n   %s\n\n", i+1, title, link)
    })
}

Analyser les différentes fonctionnalités du SERP

Un racleur complet devrait gérer plus que des résultats organiques. Voici des modèles d'analyse pour les fonctionnalités SERP les plus précieuses.

Extraits de présentation

# Python: Extract featured snippet
snippet_box = soup.select_one("div.xpdopen")
if snippet_box:
    featured = {
        "type": "featured_snippet",
        "text": snippet_box.get_text(strip=True),
        "source_url": snippet_box.select_one("a")["href"] if snippet_box.select_one("a") else None,
    }

Les gens aussi s'interrogent

# Python: Extract PAA questions
paa_questions = []
for q in soup.select("div.related-question-pair"):
    question_text = q.select_one("span")
    if question_text:
        paa_questions.append(question_text.get_text(strip=True))

Résultats des paquets locaux

# Python: Extract local pack
local_results = []
for item in soup.select("div.VkpGBb"):
    name = item.select_one(".dbg0pd")
    rating = item.select_one(".yi40Hd")
    local_results.append({
        "name": name.get_text() if name else "",
        "rating": rating.get_text() if rating else "",
    })

Gestion des blocs Google et CAPTCHAs

Google défend activement contre le grattage automatisé. Sans infrastructure proxy appropriée, vous rencontrerez des blocs dans des dizaines de requêtes. Les principaux mécanismes de défense sont les suivants :

  • Taux limite: Trop de requêtes d'un IP déclenche un code d'état 429
  • Défis de la CAPTCHA : Google sert reCAPTCHA quand il soupçonne l'automatisation
  • La réputation de la PI : Les plages IP Datacenter reçoivent plus d'examen que les IP résidentielles
  • Empreinte du navigateur : Des en-têtes manquants ou incohérents soulèvent des drapeaux

Pour les stratégies détaillées de lutte contre la détection, voir notre guide sur grattage sans être bloqué et comment les systèmes anti-bot détectent les proxies.

Stratégie de procuration recommandée

Les procurations résidentielles sont essentielles pour le grattage soutenu de Google. ProxyHat proxies résidentielles donner accès à des millions de PI 190 sites et plus, vous permettant de faire pivoter les IP automatiquement et géo-cibler vos requêtes. Conseils de configuration clés :

  • Rotation des IP sur chaque requête — ne jamais réutiliser la même IP pour des requêtes Google consécutives
  • Ajouter des retards aléatoires entre 2 et 5 secondes entre les requêtes
  • Correspondez votre Utilisateur-Agent à une vraie version de navigateur
  • Jeu hl et gl paramètres compatibles avec votre emplacement proxy

Voir Documentation ProxyHat pour la configuration d'authentification et la gestion de session.

Construction d'un gratteur de production

Passer d'un scénario à un pipeline de production exige une logique de réessayer, une sortie structurée et une surveillance. Voici une version durcie du racleur Python :

import requests
import time
import random
import json
from bs4 import BeautifulSoup
from datetime import datetime
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
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 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
]
def scrape_serp(query, location="us", retries=3):
    for attempt in range(retries):
        try:
            headers = {
                "User-Agent": random.choice(USER_AGENTS),
                "Accept-Language": "en-US,en;q=0.9",
                "Accept": "text/html,application/xhtml+xml",
            }
            response = requests.get(
                "https://www.google.com/search",
                params={"q": query, "num": 10, "hl": "en", "gl": location},
                proxies={"http": PROXY_URL, "https": PROXY_URL},
                headers=headers,
                timeout=15,
            )
            if response.status_code == 429:
                wait = (attempt + 1) * 10
                print(f"Rate limited. Waiting {wait}s...")
                time.sleep(wait)
                continue
            response.raise_for_status()
            soup = BeautifulSoup(response.text, "html.parser")
            # Check for CAPTCHA
            if "captcha" in response.text.lower() or soup.select_one("#captcha-form"):
                print(f"CAPTCHA detected. Retrying with new IP...")
                time.sleep(random.uniform(5, 10))
                continue
            return parse_serp(soup, query)
        except requests.RequestException as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            time.sleep(random.uniform(2, 5))
    return None
def parse_serp(soup, query):
    results = {
        "query": query,
        "timestamp": datetime.utcnow().isoformat(),
        "organic": [],
        "featured_snippet": None,
        "paa": [],
    }
    # Organic results
    for i, g in enumerate(soup.select("div#search .g")):
        title_el = g.select_one("h3")
        link_el = g.select_one("a")
        snippet_el = g.select_one(".VwiC3b")
        if title_el and link_el:
            results["organic"].append({
                "position": i + 1,
                "title": title_el.get_text(),
                "url": link_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
            })
    # Featured snippet
    snippet_box = soup.select_one("div.xpdopen")
    if snippet_box:
        results["featured_snippet"] = snippet_box.get_text(strip=True)[:500]
    # People Also Ask
    for q in soup.select("div.related-question-pair span"):
        results["paa"].append(q.get_text(strip=True))
    return results
# Usage: scrape a list of keywords
keywords = ["best residential proxies", "proxy for web scraping", "serp tracking tools"]
all_results = []
for kw in keywords:
    result = scrape_serp(kw)
    if result:
        all_results.append(result)
    time.sleep(random.uniform(3, 7))  # Delay between keywords
# Save to JSON
with open("serp_results.json", "w") as f:
    json.dump(all_results, f, indent=2)

Scaling Your SERP Scraper

Lorsque vous surveillez des centaines ou des milliers de mots clés, le grattage à simple filet est trop lent. Envisager ces approches d'échelle :

  • Demandes simultanées : Utilisez asyncio (Python), threads worker (Node.js), ou goroutines (Go) pour envoyer plusieurs requêtes en parallèle
  • Architecture basée sur les files d'attente: Poussez des mots-clés dans une file d'attente (Redis, RabbitMQ) et traitez-les avec plusieurs travailleurs
  • Gestion du pool mandataire : ProxyHat gère la rotation automatiquement, mais configure l'adhérence de la session en fonction de vos besoins
  • Résultat en cache : Cache données SERP pour éviter les requêtes redondantes pour la même requête dans une fenêtre de temps

Pour obtenir des conseils détaillés sur les systèmes de graissage évolutifs, lisez notre guide complet sur les proxies de raclage de toile.

Considérations juridiques et éthiques

Les conditions de service de Google limitent l'accès automatisé. Lors de la démolition de Google SERP, suivez ces lignes directrices :

  • Respecter les limites de tarifs et éviter les serveurs accablants de Google
  • Utiliser les données à des fins commerciales légitimes (suivi du référencement, études de marché)
  • Ne pas redistribuer les données brutes SERP commercialement sans comprendre les lois applicables
  • Envisager d'utiliser les API officielles de Google où ils répondent à vos besoins
Vérifiez toujours vos lois locales concernant le grattage web et la collecte de données avant de déployer un gratteur SERP à l'échelle.

Prêt à commencer ?

Accédez à plus de 50M d'IPs résidentielles dans plus de 148 pays avec filtrage IA.

Voir les tarifsProxies résidentiels
← Retour au Blog