Scrapowanie People Also Ask i Google Autocomplete do badania słów kluczowych — przewodnik w Pythonie

Dlaczego warto scrapować People Also Ask i Google Autocomplete do badania słów kluczowych

Scrapowanie People Also Ask i Google Autocomplete to jedna z najszybszych i najtańszych metod budowania bazy słów kluczowych long-tail. Te trzy źródła — Autocomplete, People Also Ask (PAA) i Related Searches — są publicznie dostępne, aktualizowane w czasie rzeczywistym i odzwierciedlają rzeczywiste intencje wyszukiwania użytkowników. W przeciwieństwie do płatnych narzędzi SEO, które często pokazują dane sprzed tygodni, Google zwraca sugestie na żywo, z dokładnością co do lokalizacji i języka.

Dla SEO specialistów i deweloperów budujących narzędzia keyword-research scraping to złota kopalnia danych. Pojedyncze słowo kluczowe może zostać rozbite na setki wariantów long-tail w kilka minut — wystarczy odpowiedni skrypt, proxy rezydencyjne i trochę cierpliwości. Ten przewodnik pokazuje, jak to zrobić w Pythonie: od prostego zapytania HTTP po pełny pipeline z Playwright, deduplikacją i eksportem do CSV.

Trzy darmowe źródła słów kluczowych od Google

Google oferuje trzy publiczne mechanizmy sugestii, z których każdy mapuje się na inną intencję wyszukiwania:

1. Google Autocomplete (suggestqueries.google.com)

Endpoint suggestqueries.google.com/complete/search?client=chrome&q=KEYWORD zwraca JSON z listą sugestii uzupełniania zapytania. To dane w czasie rzeczywistym — Google zwraca 10 sugestii na każde zapytanie, odzwierciedlając trendy, popularność i lokalizację. Intencja: informacyjna i nawigacyjna — użytkownik dopiero formułuje zapytanie.

Endpoint jest publicznie dostępny i nie wymaga klucza API, ale Google nakłada limity na szybkie, powtarzające się zapytania z tego samego IP — zwykle po około 100 żądaniach w krótkim czasie pojawia się CAPTCHA lub timeout. Dokumentacja Google Custom Search JSON API opisuje oficjalne limity, ale endpoint suggestqueries nie jest oficjalnie udokumentowany.

2. People Also Ask (PAA)

Sekcja PAA pojawia się w wynikach organicznych Google i zawiera pytania powiązane z zapytaniem. Każde pytanie rozwija się w akordeonie, odsłaniając odpowiedź i źródło cytowania. Kluczowa cecha: rozwinięcie pytania generuje nowe pytania — akordeon PAA jest rekursywny. Intencja: informacyjna — użytkownik szuka konkretnej odpowiedzi na pytanie.

PAA jest idealne do budowania treści FAQ i sekcji Q&A na stronach. Każde pytanie to gotowy nagłówek H2 lub H3 dla artykułu.

3. Related Searches (powiązane wyszukiwania)

Lista na dole strony wyników Google. Zwykle 8–10 zapytań powiązanych z oryginalnym wyszukiwaniem. Intencja: mieszana — od informacyjnej po transakcyjną. Related Searches to dobre źródło do klasyfikacji klastrów tematycznych.

Ekspander seed-to-longtail: jak zamienić jedno słowo w setki

Pojedyncze słowo kluczowe, np. buty do biegania, zwraca 10 sugestii z Autocomplete. Ale jeśli dodasz prefiksy a–z i modyfikatory, liczba rośnie wykładniczo. Algorytm:

1. Wyślij zapytanie buty do biegania → 10 sugestii.
2. Wyślij buty do biegania a, buty do biegania b, ..., buty do biegania z → do 260 sugestii.
3. Dodaj modyfikatory: jak wybrać buty do biegania, buty do biegania cena, buty do biegania opinie.
4. Dla każdej unikalnej sugestii powtórz proces rekursywnie (głębokość 2–3).

Przy głębokości 2 i 26 prefiksach jedno słowo może wygenerować ponad 500 unikalnych wariantów. To wystarczy do zbudowania mapy treści dla całej kategorii produktowej.

Dlaczego potrzebujesz proxy rezydencyjnych

Google Autocomplete i PAA są wrażliwe na dwie rzeczy: limity per-IP i lokalizację IP.

Limity per-IP

Endpoint suggestqueries.google.com nie ma oficjalnej dokumentacji limitów, ale w praktyce Google blokuje IP po około 100 szybkich zapytaniach w ciągu kilku minut. Objaw to pustą odpowiedź, HTTP 429 lub CAPTCHA. Scraper bez proxy zatrzymuje się po kilku minutach pracy.

Lokalizacja IP

Sugestie Autocomplete i pytania PAA są lokalizacyjnie zależne. Zapytanie prawnik z IP w Warszawie zwraca inne sugestie niż z IP w Berlinie czy Nowym Jorku. Jeśli badasz rynek niemiecki, musisz wysyłać zapytania z IP w Niemczech — inaczej dostaniesz zanieczyszczone dane.

Proxy rezydencyjne rozwiązują oba problemy: rotacja IP omija limity per-IP, a geo-targeting kraju i miasta zapewnia czyste, zlokalizowane sugestie. ProxyHat oferuje proxy rezydencyjne z geo-targetingiem na poziomie kraju i miasta — np. user-country-DE-city-berlin:pass kieruje ruch przez IP ISP w Berlinie.

Konfiguracja ProxyHat w Pythonie

ProxyHat używa bramy gate.proxyhat.com z portem 8080 (HTTP) lub 1080 (SOCKS5). Geo-targeting i flagi sesji przekazywane są w nazwie użytkownika.

Podstawowe połączenie HTTP

import httpx
import asyncio

# Proxy rezydencyjne z geo-targetingiem Niemiec (Berlin)
PROXY_URL = "http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080"

async def fetch_autocomplete(keyword: str, gl: str = "de", hl: str = "de") -> list[str]:
    """Pobiera sugestie Google Autocomplete jako listę stringów."""
    url = "https://suggestqueries.google.com/complete/search"
    params = {
        "client": "chrome",
        "q": keyword,
        "gl": gl,  # geolokalizacja
        "hl": hl,  # język
    }
    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) "
            "Chrome/120.0.0.0 Safari/537.36"
        ),
        "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
    }

    async with httpx.AsyncClient(proxy=PROXY_URL, timeout=15.0) as client:
        for attempt in range(3):
            try:
                resp = await client.get(url, params=params, headers=headers)
                resp.raise_for_status()
                data = resp.json()
                # Format: ["query", ["sug1", "sug2", ...], ...]
                return data[1] if len(data) > 1 else []
            except (httpx.HTTPError, httpx.ProxyError) as e:
                if attempt == 2:
                    print(f"Błąd dla '{keyword}': {e}")
                    return []
                await asyncio.sleep(2 ** attempt)  # exponential backoff
    return []

# Test
async def main():
    suggestions = await fetch_autocomplete("laufschuhe")
    print(f"Znaleziono {len(suggestions)} sugestii:")
    for s in suggestions:
        print(f"  - {s}")

asyncio.run(main())

SOCKS5 z sesją sticky

Do renderowania SERP w Playwright przyda się sesja sticky (stałe IP dla jednej sesji przeglądarki), aby zachować ciągłość i unikać CAPTCHA przy przełączaniu stron.

import httpx

# SOCKS5 z sesją sticky dla Niemiec
SOCKS5_URL = "socks5://user-session-mykeyword001-country-DE:pass@gate.proxyhat.com:1080"

async def fetch_serp_html(query: str) -> str:
    """Pobiera HTML strony wyników Google przez SOCKS5."""
    url = "https://www.google.com/search"
    params = {"q": query, "hl": "de", "gl": "de", "num": "100"}
    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) "
            "Chrome/120.0.0.0 Safari/537.36"
        ),
        "Accept-Language": "de-DE,de;q=0.9",
    }
    async with httpx.AsyncClient(proxy=SOCKS5_URL, timeout=20.0) as client:
        resp = await client.get(url, params=params, headers=headers)
        resp.raise_for_status()
        return resp.text

Pełny ekspander seed-to-longtail z prefiksami a–z

Ten skrypt bierze słowo kluczowe, generuje prefiksy a–z i modyfikatory, wysyła równolegle zapytania do Autocomplete i deduplikuje wyniki.

import httpx
import asyncio
from itertools import chain
from collections import defaultdict

PROXY_URL = "http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080"

MODIFIERS = [
    "wie", "was", "wo", "wann", "warum", "kosten", "test",
    "vergleich", "beste", "günstig", "kaufen", "erfahrungen",
]

async def fetch_suggestions(client: httpx.AsyncClient, keyword: str) -> list[str]:
    url = "https://suggestqueries.google.com/complete/search"
    params = {"client": "chrome", "q": keyword, "gl": "de", "hl": "de"}
    headers = {
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) "
            "Chrome/120.0.0.0 Safari/537.36"
        ),
    }
    try:
        resp = await client.get(url, params=params, headers=headers)
        resp.raise_for_status()
        data = resp.json()
        return data[1] if len(data) > 1 else []
    except Exception as e:
        print(f"Błąd dla '{keyword}': {e}")
        return []

async def expand_keyword(seed: str, max_concurrency: int = 5) -> dict[str, list[str]]:
    """Ekspanduje słowo kluczowe w setki wariantów long-tail."""
    # Generuj wszystkie zapytania: seed, seed + a..z, modifier + seed, seed + modifier
    prefixes = [seed] + [f"{seed} {chr(c)}" for c in range(ord('a'), ord('z') + 1)]
    modifier_queries = [f"{m} {seed}" for m in MODIFIERS] + [f"{seed} {m}" for m in MODIFIERS]
    all_queries = list(set(prefixes + modifier_queries))

    results: dict[str, list[str]] = {}
    semaphore = asyncio.Semaphore(max_concurrency)

    async with httpx.AsyncClient(proxy=PROXY_URL, timeout=15.0) as client:
        async def bounded_fetch(q: str):
            async with semaphore:
                return q, await fetch_suggestions(client, q)

        tasks = [bounded_fetch(q) for q in all_queries]
        for query, suggestions in await asyncio.gather(*tasks):
            if suggestions:
                results[query] = suggestions

    return results

async def main():
    seed = "laufschuhe"
    results = await expand_keyword(seed)

    # Deduplikacja
    all_suggestions = set()
    for suggestions in results.values():
        all_suggestions.update(suggestions)

    print(f"Seed: {seed}")
    print(f"Zapytań wysłanych: {len(results)}")
    print(f"Unikalnych sugestii: {len(all_suggestions)}")
    for s in sorted(all_suggestions)[:20]:
        print(f"  - {s}")

asyncio.run(main())

Przy 38 zapytaniach (26 prefiksów + 12 modyfikatorów) i ~10 sugestiach na zapytanie, otrzymujesz do 380 sugestii, z czego po deduplikacji zwykle 150–250 unikalnych wariantów. To z jednego słowa kluczowego.

Scrapowanie People Also Ask z Playwright

PAA wymaga renderowania strony i klikania akordeonów. Playwright to najprostszy sposób. Każde rozwinięcie pytania generuje 2–3 nowe pytania, więc proces jest rekursywny.

from playwright.async_api import async_playwright
import asyncio
import json

PROXY_SERVER = "gate.proxyhat.com:8080"
PROXY_USERNAME = "user-session-paa001-country-DE-city-berlin"
PROXY_PASSWORD = "pass"

async def scrape_paa(query: str, max_expansions: int = 20) -> list[dict]:
    """Scrapuje pytania PAA i ich źródła cytowania z Google SERP."""
    questions_data = []

    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                "server": f"http://{PROXY_SERVER}",
                "username": PROXY_USERNAME,
                "password": PROXY_PASSWORD,
            },
        )
        context = await browser.new_context(
            locale="de-DE",
            user_agent=(
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) "
                "Chrome/120.0.0.0 Safari/537.36"
            ),
        )
        page = await context.new_page()

        url = f"https://www.google.com/search?q={query}&hl=de&gl=de"
        await page.goto(url, wait_until="domcontentloaded")
        await page.wait_for_timeout(2000)  # poczekaj na załadowanie PAA

        # Znajdź wszystkie elementy PAA
        paa_selectors = page.locator("div.related-question-pair")
        count = await paa_selectors.count()

        for i in range(min(count, max_expansions)):
            try:
                element = paa_selectors.nth(i)
                question_text = await element.inner_text()

                # Kliknij aby rozwinąć i pobrać odpowiedź
                await element.click()
                await page.wait_for_timeout(1000)

                # Pobierz źródło cytowania (URL)
                source_link = element.locator("a[data-ved]")
                source_url = ""
                if await source_link.count() > 0:
                    source_url = await source_link.first.get_attribute("href") or ""

                questions_data.append({
                    "question": question_text.strip(),
                    "source_url": source_url,
                    "query": query,
                })
            except Exception as e:
                print(f"Błąd przy pytaniu {i}: {e}")
                continue

        await browser.close()

    return questions_data

async def main():
    results = await scrape_paa("laufschuhe", max_expansions=15)
    print(json.dumps(results[:5], indent=2, ensure_ascii=False))
    print(f"\nZnaleziono {len(results)} pytań PAA")

asyncio.run(main())

Rekursywne rozszerzanie PAA

Każde rozwinięte pytanie PAA odsłania 2–3 nowe pytania. Aby je przechwycić, musisz dynamicznie śledzić pojawiające się nowe elementy po każdym kliknięciu.

from playwright.async_api import async_playwright
import asyncio

async def scrape_paa_recursive(query: str, depth: int = 3) -> list[str]:
    """Rekursywnie rozwija akordeony PAA, zbierając wszystkie pytania."""
    all_questions = set()

    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                "server": "http://gate.proxyhat.com:8080",
                "username": "user-session-paa-recursive-country-DE",
                "password": "pass",
            },
        )
        page = await browser.new_page()
        await page.goto(f"https://www.google.com/search?q={query}&hl=de&gl=de")
        await page.wait_for_timeout(2000)

        for _ in range(depth):
            # Zbierz wszystkie aktualne pytania PAA
            questions = await page.evaluate("""
                () => {
                    const els = document.querySelectorAll('div.related-question-pair');
                    return Array.from(els).map(e => e.innerText.trim());
                }
            """)
            all_questions.update(questions)

            # Kliknij każdy akordeon aby odsłonić nowe pytania
            paa_count = await page.locator("div.related-question-pair").count()
            for i in range(min(paa_count, 10)):
                try:
                    el = page.locator("div.related-question-pair").nth(i)
                    await el.click()
                    await page.wait_for_timeout(800)
                except:
                    continue

        # Ostatni zbiór po wszystkich kliknięciach
        final_questions = await page.evaluate("""
            () => {
                const els = document.querySelectorAll('div.related-question-pair');
                return Array.from(els).map(e => e.innerText.trim());
            }
        """)
        all_questions.update(final_questions)
        await browser.close()

    return list(all_questions)

async def main():
    questions = await scrape_paa_recursive("laufschuhe", depth=3)
    print(f"Znaleziono {len(questions)} unikalnych pytań PAA")
    for q in questions[:10]:
        print(f"  Q: {q}")

asyncio.run(main())

Deduplikacja, klasteryzacja i eksport do CSV

Po zebraniu danych z Autocomplete i PAA musisz je oczyścić, deduplikować i wyeksportować w użytecznym formacie.

import csv
import re
from collections import defaultdict

def normalize_keyword(kw: str) -> str:
    """Normalizuje słowo kluczowe: lowercase, usuwa nadmiarowe spacje."""
    return re.sub(r'\s+', ' ', kw.strip().lower())

def cluster_by_intent(keywords: list[str]) -> dict[str, list[str]]:
    """Klasteryzuje słowa kluczowe wg intencji na podstawie modyfikatorów."""
    clusters = defaultdict(list)

    informational_markers = ["wie", "was", "warum", "wann", "wo", "guide", "tipps", "erklärung"]
    transactional_markers = ["kaufen", "bestellen", "preis", "kosten", "günstig", "rabatt"]
    navigational_markers = ["test", "vergleich", "bewertung", "erfahrungen", "review"]

    for kw in keywords:
        normalized = normalize_keyword(kw)
        if any(m in normalized for m in transactional_markers):
            clusters["transactional"].append(kw)
        elif any(m in normalized for m in navigational_markers):
            clusters["navigational"].append(kw)
        elif any(m in normalized for m in informational_markers):
            clusters["informational"].append(kw)
        else:
            clusters["general"].append(kw)

    return dict(clusters)

def export_to_csv(
    autocomplete_results: dict[str, list[str]],
    paa_questions: list[str],
    output_path: str = "keyword_research.csv",
):
    """Eksportuje wszystkie słowa kluczowe do CSV z metadanymi."""
    # Zbierz i deduplikuj
    all_keywords = set()
    for suggestions in autocomplete_results.values():
        all_keywords.update(suggestions)
    all_keywords.update(paa_questions)

    # Normalizacja i deduplikacja
    normalized = {normalize_keyword(kw): kw for kw in all_keywords}
    unique_keywords = list(normalized.values())

    # Klasteryzacja
    clusters = cluster_by_intent(unique_keywords)

    with open(output_path, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["keyword", "intent", "source", "normalized"])
        for kw in unique_keywords:
            norm = normalize_keyword(kw)
            intent = "general"
            for cluster_name, kws in clusters.items():
                if kw in kws:
                    intent = cluster_name
                    break
            source = "paa" if kw in paa_questions else "autocomplete"
            writer.writerow([kw, intent, source, norm])

    print(f"Wyeksportowano {len(unique_keywords)} unikalnych słów kluczowych do {output_path}")
    for cluster, kws in clusters.items():
        print(f"  {cluster}: {len(kws)} słów kluczowych")

# Przykład użycia (po zebraniu danych)
# export_to_csv(autocomplete_results, paa_questions, "laufschuhe_keywords.csv")

Najczęstsze błędy i przypadki brzegowe

1. Ignorowanie lokalizacji IP

Najczęstszy błąd: scrapowanie bez proxy lub z datacenter proxy. Sugestie Autocomplete z IP datacenter w USA zwrócą amerykańskie wyniki nawet jeśli ustawisz gl=de. Parametr gl to wskazówka, ale Google priorytetyzuje fizyczną lokalizację IP. Zawsze używaj proxy z geo-targetingiem kraju.

2. Zbyt szybkie zapytania

Wysyłanie 50 zapytań na sekundę z jednego IP gwarantuje blokadę. Utrzymuj 1–2 zapytania na sekundę na IP i używaj semaforów w asyncio do kontroli współbieżności.

3. Brak retry z backoffem

Google czasowo odrzuca zapytania (HTTP 429 lub pusta odpowiedź). Implementuj retry z wykładniczym backoffem — minimum 3 próby z opóźnieniem 2^n sekund.

4. PAA w różnych językach

Selektory CSS PAA mogą się różnić w zależności od języka i wersji Google. Używaj elastycznych selektorów i testuj na różnych lokalizacjach. Selektor div.related-question-pair działa dla większości wersji, ale może się zmienić.

5. Brak sesji sticky dla Playwright

Playwright z rotującym IP na każde żądanie może wywołać CAPTCHA, bo Google widzi różne IP w jednej sesji przeglądarki. Używaj flagi user-session-XXX w nazwie użytkownika ProxyHat, aby zachować stałe IP dla jednej sesji.

Konfiguracja ProxyHat — podsumowanie

ProxyHat oferuje proxy rezydencyjne, mobilne i datacenter. Do scrapowania Google Autocomplete i PAA rekomendujemy proxy rezydencyjne z geo-targetingiem. Konfiguracja:

• HTTP: http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080
• SOCKS5: socks5://user-session-abc123-country-DE:pass@gate.proxyhat.com:1080
• Rotacja: domyślnie każde połączenie dostaje nowe IP; flaga user-session-XXX zachowuje IP dla sesji sticky.
• Geo-targeting: user-country-DE (kraj), user-country-DE-city-berlin (kraj + miasto).

Zobacz dostępne lokalizacje ProxyHat i cennik proxy. Więcej o przypadkach użycia znajdziesz na stronie web scraping i SERP tracking. Pełną dokumentację techniczną znajdziesz na docs.proxyhat.com.

Etyka i legalność

Dane z Autocomplete i PAA są publicznie widoczne, ale scrapowanie Google narusza warunki korzystania Google. Praktyczne podejście:

• Ograniczaj tempo: 1–2 zapytania na sekundę na IP, pauzy między partiami.
• Sprawdzaj robots.txt: Google blokuje większość ścieżek dla botów, ale endpoint suggestqueries nie ma jawnego blokowania.
• Preferuj oficjalne API przy skali: Google Custom Search JSON API oferuje 100 zapytań dziennie za darmo, 100 USD za 1000 zapytań powyżej limitu.
• RODO / CCPA: jeśli sugestie zawierają nazwiska lub dane osobowe, zachowaj ostrożność przy przechowywaniu i przetwarzaniu.
• Nie nadużywaj: scrapowanie ma sens dla badań i prototypów; przy produkcji na dużą skalę rozważ oficjalne API lub komercyjne narzędzia SEO.

Najważniejsze wnioski

Key Takeaways:

• Google Autocomplete, PAA i Related Searches to trzy darmowe źródła słów kluczowych long-tail, z których każde mapuje się na inną intencję wyszukiwania.
• Ekspander seed-to-longtail z prefiksami a–z i modyfikatorami zamienia jedno słowo w 150–250 unikalnych wariantów.
• PAA jest rekursywne — każde rozwinięcie akordeonu generuje 2–3 nowe pytania, idealne do budowy treści FAQ.
• Proxy rezydencyjne z geo-targetingiem są obowiązkowe: rozwiązują limity per-IP i zapewniają lokalizacyjnie czyste sugestie.
• Używaj sesji sticky w Playwright (flaga user-session-XXX), aby zachować ciągłość sesji przeglądarki.
• Deduplikuj, klasteryzuj wg intencji i eksportuj do CSV dla planowania treści i FAQ.
• Przy skali produkcyjnej rozważ oficjalne API Google zamiast scrapowania.

FAQ

Czym jest scrapowanie People Also Ask i Google Autocomplete do badania słów kluczowych?

To proces automatycznego pobierania pytań z sekcji People Also Ask oraz sugestii z Google Autocomplete w celu budowy bazy słów kluczowych long-tail. Wykorzystuje się do tego skrypty w Pythonie, które wysyłają zapytania do endpointu suggestqueries.google.com lub renderują stronę wyników w Playwright. Proxy rezydencyjne zapewniają lokalizację i zapobiegają blokadom IP.

Dlaczego proxy są potrzebne przy scrapowaniu People Also Ask i Autocomplete?

Google nakłada limity per-IP na szybkie zapytania do Autocomplete i SERP, co prowadzi do blokad lub CAPTCHA po około 100 żądaniach. Dodatkowo sugestie są lokalizacyjnie zależne — wyniki z IP w Niemczech różnią się od tych z USA. Proxy rezydencyjne z geo-targetingiem kraju i miasta rozwiązują oba problemy.

Który typ proxy działa najlepiej do scrapowania People Also Ask i Autocomplete?

Proxy rezydencyjne są najlepsze, ponieważ pochodzą z prawdziwych urządzeń ISP i są trudniejsze do wykrycia. Proxy mobilne są bezpieczniejsze ale droższe. Proxy datacenter są najtańsze, ale ich pule IP są łatwiej blokowane. Kompromis to residential z rotacją sesji i geo-targetingiem kraju.

Jak unikać blokad przy scrapowaniu People Also Ask i Autocomplete?

Stosuj rotację IP z proxy rezydencyjnymi, ograniczaj tempo do 1–2 zapytań na sekundę na IP, dodawaj realistyczne nagłówki User-Agent, używaj sesji sticky w Playwright oraz implementuj retry z backoffem. Zawsze sprawdzaj robots.txt i rozważ oficjalne API przy dużych wolumenach.

Czy scrapowanie Google Autocomplete jest legalne?

Dane są publicznie widoczne, ale scrapowanie narusza warunki korzystania Google. Należy ograniczać tempo, używać proxy etycznie i preferować oficjalne API przy skali. Uwzględnij RODO/CCPA jeśli dane zawierają informacje osobowe.

Następne kroki

Masz teraz pełny pipeline: od jednego słowa kluczowego do setek wariantów long-tail z deduplikacją i eksportem do CSV. Następny krok to integracja z narzędziem SEO lub CMS — np. automatyczne generowanie tytułów artykułów z pytań PAA albo mapy treści z klastrów intencji. Sprawdź cennik ProxyHat i zacznij scrapować z czystymi, zlokalizowanymi IP już dziś.