Wie man Google-Suchergebnisse mit Proxies scrapt

Warum Scrape Google Suchergebnisse?

Google verarbeitet mehr als 8,5 Milliarden Suchvorgänge pro Tag und macht seine Suchmaschine Ergebnisse Seiten (SERPs) die wertvollste Quelle von wettbewerbsfähigen Intelligenz im Internet. Scraping Google-Suchergebnisse gibt Ihnen Zugriff auf organische Rankings, vorgestellte Schnipsel, People Auch Ask Boxen, lokale Pakete und bezahlte Anzeigen Platzierungen — alles in Echtzeit.

Ob Sie ein SERP Monitoring Pipeline oder die Durchführung einer einmaligen Keyword-Recherche, der programmatische Zugriff auf Google-Ergebnisse können Sie Workflows automatisieren, die Stunden dauern würde, um manuell abzuschließen. Häufige Anwendungsfälle umfassen:

• Tracking Ihrer eigenen Keyword-Rankings auf den Märkten
• Überwachung der Wettbewerbssicht für Zielabfragen
• Analyse der SERP-Funktionsverteilung (Snippets, Bilder, Videos)
• Erstellung von Datensätzen für SEO-Forschung und Content-Strategie

Google SERP Struktur verstehen

Bevor Sie einen Abstreifer schreiben, müssen Sie die Anatomie einer Google-Ergebnisseite verstehen. Ein modernes SERP kann über ein Dutzend verschiedene Ergebnistypen enthalten:

Google ändert Klassennamen häufig. Bauen Sie Ihren Parser mit Fallback-Selektoren und testen Sie regelmäßig, um die Extraktion zuverlässig zu halten.

Einrichten Ihrer Scrap-Umgebung

Um Google zuverlässig abzukratzen, benötigen Sie drei Komponenten: einen HTTP-Client, eine Proxy-Verbindung und einen HTML-Parser. Im Folgenden sind vollständige Beispiele in Python, Node.js und Go using ProxyHat-Proxis.

Python Beispiel

Installieren Sie zuerst die Abhängigkeiten. Die ProxyHat Python SDK vereinfacht die Proxy-Konfiguration.

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")

Node.js Beispiel

Verwendung von ProxyHat Node SDK und Cheerio für Parsing:

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);

Beispiel

Verwendung von ProxyHat gehen SDK und Goquery:

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)
    })
}

Parsing verschiedene SERP-Funktionen

Ein kompletter Abstreifer sollte mehr als nur organische Ergebnisse behandeln. Hier sind Parsing-Muster für die wertvollsten SERP-Funktionen.

Empfohlene Snippets

# 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,
    }

Menschen auch Fragen

# 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))

Ergebnisse der lokalen Pakete

# 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 "",
    })

Umgang mit Google Blocks und CAPTCHAs

Google verteidigt aktiv gegen automatisiertes Abkratzen. Ohne richtige Proxy-Infrastruktur werden Sie Blöcke innerhalb von Dutzenden von Anfragen treffen. Die wichtigsten Verteidigungsmechanismen umfassen:

• Grenzwerte: Zu viele Anfragen von einem IP löst einen 429 Statuscode aus
• CAPTCHA Herausforderungen: Google dient reCAPTCHA, wenn es die Automatisierung vermutet
• IP-Reputation: Datacenter IP-Bereiche erhalten mehr Kontrolle als Wohn-IPs
• Browser Fingerabdruck: Fehlende oder inkonsistente Header werfen Flaggen

Detaillierte Anti-Detektionsstrategien finden Sie in unserem Leitfaden Schrott ohne Blockierung und wie Anti-Bot-Systeme Proxis erkennen.

Empfohlene Proxy Strategie

Wohn-Proxies sind essentiell für nachhaltige Google-Schrott. ProxyHat Wohnwagen Zugang zu Millionen von IPs über 190+ Standorte, so dass Sie IPs automatisch drehen und Ihre Anfragen geo-target. Tipps zur Konfiguration:

• IPs auf jeder Anfrage drehen – nie wieder dieselbe IP für aufeinanderfolgende Google-Abfragen verwenden
• Fügen Sie zufällige Verzögerungen zwischen 2-5 Sekunden zwischen Anfragen hinzu
• Passen Sie Ihren User-Agent auf eine echte Browser-Version
• Set hl und gl Parameter im Einklang mit Ihrem Proxy-Standort

Refer ProxyHat Dokumentation zur Authentisierung und Sitzungsverwaltung.

Bau eines Produktionsschraps

Das Bewegen von einem Skript in eine Produktionspipeline erfordert Retry-Logik, strukturierte Ausgabe und Überwachung. Hier ist eine gehärtete Version des Python-Schrotters:

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

Bei der Überwachung von Hunderten oder Tausenden von Keywords ist eingängiges Abkratzen zu langsam. Betrachten Sie diese Skalierungsansätze:

• Gleichzeitige Anfragen: Verwenden Sie Asyncio (Python), Worker Threads (Node.js), oder Goroutines (Go), um mehrere Anfragen parallel zu senden
• Queue-basierte Architektur: Schieben Sie Keywords in eine Warteschlange (Redis, RabbitMQ) und bearbeiten Sie sie mit mehreren Arbeitern
• Proxy Pool Management: ProxyHat behandelt die Rotation automatisch, aber konfigurieren Sie die Session Stickiness basierend auf Ihren Bedürfnissen
• Ergebnis Caching: Cache SERP-Daten, um redundante Anfragen für dieselbe Abfrage innerhalb eines Zeitfensters zu vermeiden

Für umfassende Anleitungen zum Bau von skalierbaren Abstreifsystemen lesen Sie unsere komplette Führung für Bahnabstreifer.

Rechtliche und ethische Überlegungen

Googles Nutzungsbedingungen beschränken den automatisierten Zugriff. Wenn Sie Google SERPs kratzen, folgen Sie diesen Richtlinien:

• Überprüfen Sie die Geschwindigkeitsgrenzen und vermeiden Sie überwältigende Server von Google
• Verwenden Sie die Daten zu legitimen Geschäftszwecken (SEO-Überwachung, Marktforschung)
• Nicht rohe SERP-Daten kommerziell umverteilen, ohne geltende Gesetze zu verstehen
• Betrachten Sie die Verwendung der offiziellen APIs von Google, wo sie Ihre Bedürfnisse erfüllen

Überprüfen Sie immer Ihre lokalen Gesetze bezüglich Web-Schrott und Datenerfassung, bevor Sie einen SERP-Schrotter im Maßstab bereitstellen.