Śledzenie SERP i SEO 9 min czytania

Jak scrape Google Search Results with Proxies

Dowiedz się, jak skrobać serwery Google za pomocą proxy mieszkaniowe. Kompletne przykłady kodowe w Python, Node.js i Go do ekstrakcji wyników organicznych, wyświetlane snippety i ludzie również zapytać danych.

ProxyHat Team
Jak scrape Google Search Results with Proxies

Dlaczego Scrape Google Producenci z wyszukiwania?

Google przetwarza ponad 8,5 mld wyszukiwań dziennie, czyniąc swoje strony wyników wyszukiwarek (SERP) najcenniejszym źródłem konkurencyjnej inteligencji w sieci. Rozdrabnianie wyników wyszukiwania Google daje dostęp do rankingów organicznych, wyświetlanych snippetów, Ludzie również zapytać pudełka, lokalne pakiety i płatnych miejsc reklamowych - wszystko w czasie rzeczywistym.

Czy budujesz Gazociąg monitorowania SERP lub prowadzenie badań jednego słowa kluczowego, program dostępu do wyników Google pozwala na automatyzację przepływów pracy, które zajęłyby godziny, aby zakończyć ręcznie. Do częstych przypadków stosowania należą:

  • Śledzenie własnych rankingów słów kluczowych na rynkach
  • Monitorowanie widoczności konkurenta dla zapytań docelowych
  • Analiza dystrybucji funkcji SERP (snippety, obrazy, filmy)
  • Zestawienie danych dotyczących badań SEO i strategii dotyczącej treści

Zrozumienie struktury Google SERP

Przed napisaniem scrapera, musisz zrozumieć anatomię strony wyników Google. Nowoczesny SERP może zawierać ponad tuzin różnych typów wyników:

Typ wynikuCSS / Znacznik danychOpis
Wyniki ekologicznediv#search .gStandardowe wyniki połączenia blue- link z tytułem, URL i snippet
Promowane skrawkidiv.xpdopenOkno odpowiedzi wyświetlane powyżej wyników ekologicznych
Ludzie też pytajądiv.related-question-pairRozszerzalne pytania w stylu FAQ- style
Opakowanie lokalnediv.VkpGBbMapa z 3 lokalnych wykazów biznesowych
Panel wiedzydiv.kp-wholepageKod identyfikacyjny podmiotu
Wyniki ogłoszeńdiv.uEierdPłatne reklamy wyszukiwania na górze i dole
Google często zmienia nazwy klas. Zbuduj parser z selekcjonerów awaryjnych i regularnie testować, aby utrzymać niezawodność ekstrakcji.

Ustawianie swojego środowiska scraping

Aby skrobać Google niezawodnie, potrzebujesz trzech komponentów: klienta HTTP, połączenia proxy i parsera HTML. Poniżej znajdują się kompletne przykłady w Python, Node.js i Go przy użyciu ProksyHat proxy.

Przykład Pythona

Najpierw zainstaluj zależności. W ProxyHat Python SDK upraszcza konfigurację 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")

Przykład node.js

Korzystanie z ProxyHat Node SDK i Cheerio do parsowania:

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

Przykład Go

Korzystanie z ProxyHat Go SDK i 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)
    })
}

Parowanie różnych funkcji SERP

Kompletny drapacz powinien obsługiwać coś więcej niż tylko organiczne wyniki. Oto wzory parsowania dla najcenniejszych funkcji SERP.

Promowane Snippety

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

Ludzie też pytają

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

Lokalne wyniki opakowania

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

Obsługa Google Blocks i CAPTCHA

Google aktywnie broni przed automatycznym skrobaniem. Bez odpowiedniej infrastruktury proxy, napotkasz bloki w ciągu kilkunastu żądań. Kluczowe mechanizmy obronne obejmują:

  • Ograniczenie stawki: Zbyt wiele żądań z jednego IP uruchamia kod statusu 429
  • Wyzwania CAPTCHA: Google obsługuje reCAPTCHA, gdy podejrzewa automatyzację
  • Reputacja IP: Przedziały IP Datacenter otrzymują większą kontrolę niż IP mieszkaniowe
  • Pobieranie odcisków palców przez przeglądarkę: Brakujące lub niespójne nagłówki podnoszą flagi

Szczegółowe strategie antydetekcji, zobacz nasz przewodnik na skrobanie bez blokowania oraz jak systemy anty-bot wykrywają proxy.

Zalecana strategia proxy

Proxy mieszkaniowe są niezbędne do długotrwałego skanowania Google. ProxyHat proxy mieszkalne zapewnienie dostępu do milionów IP we wszystkich 190 + lokalizacje, pozwalając na automatyczne obracanie IP i geologię swoich żądań. Kluczowe wskazówki konfiguracji:

  • Obróć IP na każde żądanie - nigdy nie używaj tego samego IP dla kolejnych zapytań Google
  • Dodaj losowe opóźnienia między 2- 5 sekundami pomiędzy żądaniami
  • Dopasuj swój User- Agent do prawdziwej wersji przeglądarki
  • Ustaw hl oraz gl parametry zgodne z lokalizacją proxy

Patrz Dokumentacja ProxyHat dla konfiguracji uwierzytelniania i zarządzania sesjami.

Budowa scrappera produkcyjnego

Przejście od scenariusza do rurociągu produkcyjnego wymaga powtórnej logiki, strukturalnej produkcji i monitorowania. Oto hartowana wersja drapacza Pythona:

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)

Skalowanie Twojego skanera SERP

Podczas monitorowania setek lub tysięcy słów kluczowych, pojedynczy gwintowany scrating jest zbyt powolny. Rozważcie te podejścia do skalowania:

  • Równoczesne wnioski: Użyj asyncio (Python), wątków pracowniczych (Node.js) lub goroutines (Go), aby wysłać wiele żądań równolegle
  • Architektura oparta na kolejkach: Wciśnij słowa kluczowe do kolejki (Redis, RabbitMQ) i przetwarzaj je z wieloma pracownikami
  • Zarządzanie pulą proxy: ProxyHat automatycznie obsługuje rotację, ale skonfigurować klejenie sesji w zależności od potrzeb
  • Wynik buforowania: Cache SERP dane, aby uniknąć zbędnych żądań dla tego samego zapytania w oknie czasowym

Aby uzyskać kompleksowe wskazówki na temat budowy skalowalnych systemów skrawania, przeczytaj nasz Kompletny przewodnik po proxy do skrobania stron internetowych.

Rozważania prawne i etyczne

Warunki korzystania z Google ograniczają zautomatyzowany dostęp. Podczas zeskrobywania serwerów Google należy postępować zgodnie z poniższymi wytycznymi:

  • Poszanowanie limitów stawek i uniknąć przytłaczających serwerów Google
  • Wykorzystanie danych do uzasadnionych celów biznesowych (monitorowanie SEO, badania rynku)
  • Nie należy redystrybuować surowych danych SERP w celach handlowych bez zrozumienia obowiązujących przepisów
  • Rozważenie korzystania z oficjalnych API Google, gdzie spełniają Twoje potrzeby
Zawsze sprawdzaj lokalne przepisy dotyczące zeskrobywania stron internetowych i gromadzenia danych przed umieszczeniem w skali skanera SERP.

Gotowy, aby zacząć?

Dostęp do ponad 50 mln rezydencjalnych IP w ponad 148 krajach z filtrowaniem AI.

Zobacz cenyProxy rezydencjalne
← Powrót do Bloga