Scraping SERP Google vs Bing : différences clés

Pourquoi comparer Google et Bing Scraping?

Alors que Google domine la recherche avec plus de 90% de parts de marché à l'échelle mondiale, Bing détient une part importante sur des marchés spécifiques : environ 9% aux États-Unis, plus élevé parmi les utilisateurs d'entreprise, et il permet des résultats de recherche pour DuckDuckGo, Yahoo et Ecosia. Pour une surveillance SERP complète, le suivi des deux moteurs de recherche vous donne une vue plus complète de votre visibilité organique.

Les différences techniques entre Google et Bing sont importantes. Chaque moteur de recherche a des structures HTML différentes, des protections anti-bot, des limites de taux et des exigences de proxy. Ce guide décompose ces différences afin que vous puissiez construire des racleurs qui fonctionnent de façon fiable pour les deux.

Pour les concepts fondamentaux de grattage SERP, commencez par notre SERP raclage avec guide proxies.

Comparaison de la protection anti-bot

La plus grande différence entre le grattage de Google et Bing est à quel point chaque moteur de recherche détecte et bloque les demandes automatisées.

La clé à retenir : Bing est beaucoup plus facile à gratter que Google. Vous pouvez souvent utiliser des proxies de datacenter pour Bing à des volumes modérés, tandis que Google nécessite presque toujours des proxies résidentielles pour des résultats fiables.

Différences de structure HTML

Google et Bing utilisent des structures HTML complètement différentes pour leurs résultats de recherche, nécessitant une logique d'analyse séparée.

Google SERP Structure

# Google organic result selectors
# Container: div#search .g
# Title: h3
# URL: a[href]
# Snippet: .VwiC3b or div[data-snf]
from bs4 import BeautifulSoup
def parse_google(html):
    soup = BeautifulSoup(html, "html.parser")
    results = []
    for g in soup.select("div#search .g"):
        title = g.select_one("h3")
        link = g.select_one("a")
        snippet = g.select_one(".VwiC3b")
        if title and link:
            results.append({
                "title": title.get_text(),
                "url": link["href"],
                "snippet": snippet.get_text() if snippet else "",
            })
    return results

Structure du SERP

# Bing organic result selectors
# Container: li.b_algo
# Title: h2 a
# URL: cite
# Snippet: p.b_lineclamp2 or div.b_caption p
def parse_bing(html):
    soup = BeautifulSoup(html, "html.parser")
    results = []
    for item in soup.select("li.b_algo"):
        title_el = item.select_one("h2 a")
        snippet_el = item.select_one("p.b_lineclamp2") or item.select_one("div.b_caption p")
        cite_el = item.select_one("cite")
        if title_el:
            results.append({
                "title": title_el.get_text(),
                "url": title_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
                "display_url": cite_el.get_text() if cite_el else "",
            })
    return results

Comparaison des caractéristiques du SERP

Les deux moteurs de recherche affichent de riches fonctionnalités SERP au-delà des liens bleus standard, mais ils diffèrent en format et en fréquence:

Grattoir à double moteur complet

Voici un racleur Python unifié qui gère à la fois Google et Bing:

import requests
from bs4 import BeautifulSoup
import time
import random
import json
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",
]
def scrape_serp(keyword, engine="google", country="us"):
    """Scrape SERP from Google or Bing."""
    proxies = {"http": PROXY_URL, "https": PROXY_URL}
    headers = {
        "User-Agent": random.choice(USER_AGENTS),
        "Accept-Language": "en-US,en;q=0.9",
        "Accept": "text/html,application/xhtml+xml",
    }
    if engine == "google":
        url = "https://www.google.com/search"
        params = {"q": keyword, "num": 10, "hl": "en", "gl": country}
    else:
        url = "https://www.bing.com/search"
        params = {"q": keyword, "count": 10, "cc": country}
    response = requests.get(
        url,
        params=params,
        headers=headers,
        proxies=proxies,
        timeout=15,
    )
    response.raise_for_status()
    soup = BeautifulSoup(response.text, "html.parser")
    if engine == "google":
        return parse_google_results(soup)
    else:
        return parse_bing_results(soup)
def parse_google_results(soup):
    results = []
    for i, g in enumerate(soup.select("div#search .g"), 1):
        title = g.select_one("h3")
        link = g.select_one("a")
        snippet = g.select_one(".VwiC3b")
        if title and link:
            results.append({
                "position": i,
                "title": title.get_text(),
                "url": link["href"],
                "snippet": snippet.get_text() if snippet else "",
            })
    return results
def parse_bing_results(soup):
    results = []
    for i, item in enumerate(soup.select("li.b_algo"), 1):
        title_el = item.select_one("h2 a")
        snippet_el = item.select_one("p.b_lineclamp2") or item.select_one("div.b_caption p")
        if title_el:
            results.append({
                "position": i,
                "title": title_el.get_text(),
                "url": title_el["href"],
                "snippet": snippet_el.get_text() if snippet_el else "",
            })
    return results
# Compare rankings across both engines
keyword = "best web scraping proxies"
google_results = scrape_serp(keyword, "google")
time.sleep(random.uniform(3, 6))
bing_results = scrape_serp(keyword, "bing")
print(f"\n=== Google Results for '{keyword}' ===")
for r in google_results[:5]:
    print(f"  #{r['position']}: {r['title']}")
print(f"\n=== Bing Results for '{keyword}' ===")
for r in bing_results[:5]:
    print(f"  #{r['position']}: {r['title']}")

Node.js Grattoir à double moteur

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 scrapeSERP(keyword, engine = 'google') {
  const config = engine === 'google'
    ? { url: 'https://www.google.com/search', params: { q: keyword, num: 10, hl: 'en', gl: 'us' } }
    : { url: 'https://www.bing.com/search', params: { q: keyword, count: 10 } };
  const { data } = await axios.get(config.url, {
    params: config.params,
    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);
  if (engine === 'google') {
    return parseGoogle($);
  }
  return parseBing($);
}
function parseGoogle($) {
  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;
}
function parseBing($) {
  const results = [];
  $('li.b_algo').each((i, el) => {
    const titleEl = $(el).find('h2 a');
    const title = titleEl.text();
    const url = titleEl.attr('href');
    const snippet = $(el).find('p.b_lineclamp2').text() || $(el).find('div.b_caption p').text();
    if (title && url) results.push({ position: i + 1, title, url, snippet });
  });
  return results;
}
async function compareEngines(keyword) {
  const [google, bing] = await Promise.all([
    scrapeSERP(keyword, 'google'),
    scrapeSERP(keyword, 'bing'),
  ]);
  console.log(`\nGoogle (${google.length} results):`);
  google.slice(0, 5).forEach(r => console.log(`  #${r.position}: ${r.title}`));
  console.log(`\nBing (${bing.length} results):`);
  bing.slice(0, 5).forEach(r => console.log(`  #${r.position}: ${r.title}`));
}
compareEngines('residential proxy service');

Comparaison des exigences en matière de procuration

La stratégie de remplacement pour chaque moteur devrait différer en fonction de ses niveaux de détection:

Pour Google

• Type de mandataire: Proxies résidentielles nécessaires pour obtenir des résultats fiables
• Rotation: Rotation IP sur chaque requête
• Taux 1-2 requêtes par minute par IP
• En-têtes: Jeu complet d'en-têtes de type navigateur avec Sec-Ch-Ua, Sec-Fetch
• Ciblage géographique: Corriger l'emplacement du proxy avec les paramètres gl/hl

Pour Bing

• Type de mandataire: Proxies de datacenter souvent suffisant; résidentiel pour l'échelle
• Rotation: Peut réutiliser les IP pour 3-5 requêtes avant de tourner
• Taux 3-5 requêtes par minute par IP
• En-têtes: En-têtes standard Utilisateur-Agent et Accepter sont généralement suffisants
• Ciblage géographique: Utiliser le paramètre cc; la géo-appariement IP moins critique

ProxyHat proxies résidentielles travailler de manière optimale pour les deux moteurs. Pour le grattage Bing seulement à volume modéré, les proxies de datacenter peuvent suffire, mais les proxies résidentielles de ProxyHat fournissent des résultats cohérents pour les deux moteurs sans avoir besoin d'une infrastructure séparée. Voir la documentation pour les détails de configuration.

Comparaison des paramètres URL

Quand suivre les deux moteurs

Le suivi de Google et de Bing est particulièrement utile dans ces scénarios :

• Marchés des entreprises: Bing a une part de marché plus élevée parmi les utilisateurs d'entreprise grâce à l'intégration Microsoft Edge et Windows
• Orientation du marché américain: Bing détient environ 9% du trafic de recherche américain, représentant des millions de visiteurs potentiels
• Recherche vocale : Bing pouvoirs Cortana et quelques résultats d'assistant de voix
• Diversité algorithmique : Classement bien sur Bing nécessite souvent différentes stratégies d'optimisation que Google
• DuckDuckGo et Yahoo trafic: Les deux utilisent l'indice de Bing, donc les classements de Bing affectent ces plateformes aussi

Traitement des cas de bord

Bing Domaines spécifiques au marché

Contrairement à Google qui utilise google.com avec gl paramètre pour tous les pays, Bing a des domaines spécifiques à chaque pays:

# Bing country-specific URLs
BING_DOMAINS = {
    "us": "https://www.bing.com/search",
    "uk": "https://www.bing.co.uk/search",
    "de": "https://www.bing.de/search",
    "fr": "https://www.bing.fr/search",
    "jp": "https://www.bing.co.jp/search",
}

Pagination différente

# Google pagination: start parameter (0, 10, 20, ...)
google_page_2 = {"q": "query", "start": 10, "num": 10}
# Bing pagination: first parameter (1, 11, 21, ...)
bing_page_2 = {"q": "query", "first": 11, "count": 10}

Bâtir un tracker SERP multimoteur avec une infrastructure de proxy unifiée est l'approche la plus efficace. Les mandataires résidentiels ProxyHat gèrent Google et Bing avec la même connexion, simplifiant votre architecture tout en assurant des résultats fiables des deux moteurs.

Pour en savoir plus sur la construction d'infrastructures robustes de démolition, consultez nos guides sur utilisant des proxies dans Python, utilisant des proxies dans Node.js, et notre meilleurs proxies pour le grattage de toile Aperçu général. Vérifier Solutions de suivi de ProxyHat SERP pour les configurations sur mesure.