Google People Also Ask ve Autocomplete Kazıma Rehberi: Python ile Anahtar Kelime Araştırması

Google People Also Ask ve Autocomplete Kazıma Nedir?

Anahtar kelime araştırması için Google People Also Ask ve Autocomplete kazıma, SEO uzmanlarının ve geliştiricilerin en değerli veri kaynaklarından biridir. Google'ın otomatik tamamlama önerileri ve PAA soruları, gerçek kullanıcı sorgularını yansıtır ve çoğu geleneksel anahtar kelime aracının kaçırdığı uzun kuyruklu fırsatları ortaya çıkarır. Bu rehberde, Python ile bu verileri nasıl toplayacağınızı, residential proxy kullanarak engellemeleri nasıl aşacağınızı ve sonuçları içerik planlaması için nasıl düzenleyeceğinizi göstereceğiz.

Google'ın ücretsiz sunduğu üç temel veri kaynağı vardır: Autocomplete önerileri, People Also Ask soruları ve Related Searches. Her biri farklı bir arama niyetini yansıtır ve birlikte kullanıldığında kapsamlı bir anahtar kelime haritası oluşturur. Yıllık binlerce dolar tutan premium SEO araçlarının çoğu, temelinde bu verileri toplar ve işler.

Üç Bedava Anahtar Kelime Altın Madeni

Google arama deneyimi, kullanıcı niyetini ortaya çıkaran üç açık veri kaynağı sunar. Her birinin yapısı, erişim yöntemi ve kullanım senaryosu farklıdır.

1. Autocomplete (Otomatik Tamamlama) Endpoint'i

Google'ın otomatik tamamlama önerileri, suggestqueries.google.com/complete/search?client=chrome&q= endpoint'i üzerinden JSON formatında erişilebilir. Bu endpoint, Google arama çubuğuna yazdığınız her harf için gerçek zamanlı öneriler döndürür ve her sorgu için yaklaşık 10 öneri sunar.

Basit bir curl isteğiyle başlayalım:

curl -s "https://suggestqueries.google.com/complete/search?client=chrome&q=python" \
  --proxy "http://user-country-US:pass@gate.proxyhat.com:8080" \
  -H "User-Agent: Mozilla/5.0"

Yanıt, [query, [[suggestion, type], ...], ...] formatında bir JSON dizisidir. client=chrome parametresi en zengin öneri setini döndürür — client=firefox veya client=toolbar alternatifleri daha az öneri verir.

2. People Also Ask (PAA) Soruları

PAA kutuları, Google SERP'lerinde genellikle ilk sonuçların altında görünür ve her bir soru, tıklandığında yeni alt soruları açan bir akordeon yapısına sahiptir. Bu iç içe geçmiş yapı, tek bir anahtar kelimeden onlarca ilgili soru üretmenizi sağlar. PAA soruları ağırlıklı olarak bilgi arayan (informational) niyeti yansıtır ve Google'ın FAQ yapılandırılmış veri yönergelerine uygun içerik planlaması için idealdir.

3. Related Searches (İlgili Aramalar)

SERP'nin en altında yer alan Related Searches, bir anahtar kelime için Google'ın önerdiği benzer aramaları listeler. Bu bölüm, geniş niyet kümelerini keşfetmek için yararlıdır ancak Autocomplete kadar derin değildir.

Teknik Bağlam: Neden Rate Limit ve Lokal Sapma Sorunu Vardır?

Google'ın autocomplete ve PAA endpoint'leri, kullanıcı deneyimi için optimize edilmiştir ve otomatik bot trafiğini engellemek için katı per-IP rate limitleri uygular. Tek bir IP adresinden saniyede 5-10 istek gönderdiğinizde, Google genellikle 429 Too Many Requests yanıt kodu döndürür veya CAPTCHA sayfasına yönlendirir. MDN Web Docs, 429 durum kodunun "kullanıcının kısa süre içinde çok fazla istek gönderdiğini" belirttiğini doğrular.

İkinci sorun ise lokal sapmadır (locale bias). Google, isteğin geldiği IP coğrafyasına göre autocomplete önerilerini ve PAA sorularını kişiselleştirir. Örneğin, Almanya'dan yapılan bir "best laptop" sorgusu, ABD'deki sonuçlardan farklı öneriler döndürebilir. Bu, çoklu pazarlarda çalışan SEO ekipleri için kritik bir sorundur.

İşte bu noktada residential proxy'ler devreye girer. ProxyHat'ın gate.proxyhat.com:8080 gateway'i üzerinden, kullanıcı adında ülke ve şehir belirteci kullanarak lokalize edilmiş öneriler alabilirsiniz:

# Berlin, Almanya lokasyonundan autocomplete
http://user-country-DE-city-berlin:pass@gate.proxyhat.com:8080

# Tokyo, Japonya lokasyonundan autocomplete
http://user-country-JP-city-tokyo:pass@gate.proxyhat.com:8080

Bu yaklaşım, her pazar için doğru lokal önerileri almanızı ve aynı zamanda IP başına rate limitlerini dağıtarak engellenmeyi önlemenizi sağlar. ProxyHat'ın proxy lokasyonları sayfasından mevcut tüm ülkeleri görebilirsiniz.

Python ile Autocomplete Kazıma: httpx + Proxy

Şimdi Python tarafına geçelim. httpx kütüphanesi, proxy desteği ve async yetenekleri sayesinde bu iş için idealdir. Aşağıdaki örnek, ProxyHat residential proxy üzerinden autocomplete önerilerini çeker:

import httpx
import json
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def fetch_autocomplete(keyword: str, country: str = "US") -> list[str]:
    """Google Autocomplete'ten öneri listesi alır."""
    url = "https://suggestqueries.google.com/complete/search"
    params = {"client": "chrome", "q": keyword}
    proxy = f"http://user-country-{country}:pass@gate.proxyhat.com:8080"
    
    try:
        with httpx.Client(proxy=proxy, timeout=10) as client:
            resp = client.get(url, params=params)
            if resp.status_code == 429:
                logger.warning(f"Rate limited on keyword: {keyword}")
                return []
            resp.raise_for_status()
            data = resp.json()
            # Format: [query, [[suggestion, type], ...], ...]
            suggestions = [item[0] for item in data[1]]
            logger.info(f"Fetched {len(suggestions)} suggestions for '{keyword}'")
            return suggestions
    except httpx.HTTPError as e:
        logger.error(f"HTTP error for '{keyword}': {e}")
        return []

# Temel kullanım
for kw in fetch_autocomplete("python web"):
    print(kw)

Bu kod tek bir anahtar kelime için 10 öneri döndürür. Ancak asıl güç, bir tohum kelimeyi yüzlerce sorguya genişlettiğinizde ortaya çıkar.

Tohumdan Long-tail'e: A-Z ve Modifikatör Genişletici

Tek bir "python" tohum kelimesi, autocomplete ile sadece 10 öneri verir. Ancak her harfi ayrı bir sorgu olarak gönderirseniz ("python a", "python b", ..., "python z"), 260+ öneri alırsınız. Modifikatör ekleyerek bu sayıyı katlayabilirsiniz:

import string
import time

def expand_seed(seed: str) -> list[str]:
    """Tohum kelimeyi a-z ve modifikatör prefix'leri ile genişletir."""
    modifiers = [
        "how to", "best", "why", "what is", "when to",
        "vs", "tutorial", "examples", "guide", "tips",
        "for beginners", "without", "with", "online", "free"
    ]
    alphabet = list(string.ascii_lowercase)
    
    queries = set()
    # A-Z genişletme: "python a", "python b", ...
    for letter in alphabet:
        queries.add(f"{seed} {letter}")
    # Modifikatör genişletme: "how to python", "python best", ...
    for mod in modifiers:
        queries.add(f"{mod} {seed}")
        queries.add(f"{seed} {mod}")
    
    return list(queries)

def collect_suggestions(seed: str, country: str = "US") -> set[str]:
    """Tohumdan genişletilmiş tüm sorgular için autocomplete önerileri toplar."""
    all_suggestions = set()
    expanded_queries = expand_seed(seed)
    
    for i, q in enumerate(expanded_queries):
        suggestions = fetch_autocomplete(q, country)
        all_suggestions.update(suggestions)
        # Rate limit'e takılmamak için 2 saniye bekle
        time.sleep(2)
        if i % 10 == 0:
            logger.info(f"Progress: {i}/{len(expanded_queries)} queries, "
                        f"{len(all_suggestions)} unique suggestions")
    
    return all_suggestions

# Tek tohumdan 500+ öneri topla
results = collect_suggestions("python", country="US")
print(f"Toplam {len(results)} benzersiz öneri")

Bu yöntemle tek bir tohum kelimeden 500-1,000+ benzersiz öneri toplayabilirsiniz. İstekler arasında 2 saniye bekleme koyarak tek bir IP için güvenli bir hız tutturmuş olursunuz. Daha hızlı gitmek için proxy rotasyonu kullanmanız gerekir.

Proxy Rotasyonu ile Paralel Kazıma

Tek bir IP ile 2 saniyelik bekleme, 50 genişletilmiş sorgu için 100 saniye demektir. ProxyHat'ın session-based rotasyonu ile bu süreyi dramatik şekilde kısaltabilirsiniz:

import httpx
import random
import time
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProxyRotator:
    """ProxyHat residential proxy ile ülke bazlı rotasyon."""
    
    def __init__(self, countries: list[str], max_retries: int = 3):
        self.countries = countries
        self.max_retries = max_retries
    
    def get_proxy_url(self, country: str, session_id: str = None) -> str:
        username = f"user-country-{country}"
        if session_id:
            username += f"-session-{session_id}"
        return f"http://{username}:pass@gate.proxyhat.com:8080"
    
    def fetch_with_retry(self, keyword: str) -> list[str]:
        url = "https://suggestqueries.google.com/complete/search"
        params = {"client": "chrome", "q": keyword}
        
        for attempt in range(self.max_retries):
            country = random.choice(self.countries)
            session = f"sess{random.randint(1000, 9999)}"
            proxy = self.get_proxy_url(country, session)
            
            try:
                with httpx.Client(proxy=proxy, timeout=10) as client:
                    resp = client.get(url, params=params)
                    if resp.status_code == 429:
                        logger.warning(f"429 from {country}, retry {attempt+1}")
                        time.sleep(1)
                        continue
                    resp.raise_for_status()
                    data = resp.json()
                    return [item[0] for item in data[1]]
            except Exception as e:
                logger.error(f"Attempt {attempt+1} failed for '{keyword}': {e}")
                time.sleep(0.5)
        
        return []

def parallel_autocomplete(queries: list[str], workers: int = 5) -> set[str]:
    """Çoklu proxy ile paralel autocomplete kazıma."""
    rotator = ProxyRotator(["US", "GB", "DE", "FR", "NL"])
    all_suggestions = set()
    
    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = {
            executor.submit(rotator.fetch_with_retry, q): q 
            for q in queries
        }
        for future in as_completed(futures):
            suggestions = future.result()
            all_suggestions.update(suggestions)
    
    return all_suggestions

# 50 sorguyu 5 paralel worker ile çalıştır
expanded = expand_seed("python")
results = parallel_autocomplete(expanded, workers=5)
print(f"Toplam {len(results)} benzersiz öneri")

5 paralel worker ile 50 sorgu, yaklaşık 20 saniyede tamamlanır — tek IP ile 100 saniye sürmesine kıyasla 5 kat hızlanma. ProxyHat pricing sayfasından residential proxy paketlerini inceleyebilirsiniz.

Playwright ile People Also Ask Kazıma

PAA soruları, HTML accordion yapısında olduğu için basit HTTP istekleriyle tam olarak alınamaz. Her soru, tıklandığında yeni alt soruları ortaya çıkaran bir JavaScript etkileşimi gerektirir. Playwright, bu tarz dinamik içerik için idealdir:

from playwright.sync_api import sync_playwright
import json
import time

def scrape_paa(keyword: str, proxy_url: str, max_depth: int = 3) -> list[dict]:
    """Google SERP'ten PAA sorularını ve kaynaklarını çıkarır."""
    questions = []
    seen = set()
    
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=True,
            proxy={"server": proxy_url}
        )
        page = browser.new_page()
        page.goto(f"https://www.google.com/search?q={keyword}")
        page.wait_for_selector("div[jsname]", timeout=15000)
        
        for depth in range(max_depth):
            # PAA accordion elemanlarını bul
            paa_blocks = page.query_selector_all('div[jsname="Cpkphb"]')
            
            for block in paa_blocks:
                q_elem = block.query_selector('div[jsname="pkPHb"]')
                if not q_elem:
                    continue
                
                question = q_elem.inner_text().strip()
                if question in seen:
                    continue
                seen.add(question)
                
                # Tıkla ve alt soruları aç
                try:
                    block.click()
                    page.wait_for_timeout(800)
                except:
                    continue
                
                # Kaynak linklerini topla
                source_links = page.query_selector_all('a[jsname="UWQkNb"]')
                sources = [l.get_attribute("href") for l in source_links[:3]]
                
                questions.append({
                    "question": question,
                    "depth": depth,
                    "sources": sources
                })
            
            time.sleep(1)
        
        browser.close()
    
    return questions

# ProxyHat residential proxy ile PAA kazıma
proxy = "http://user-country-US:pass@gate.proxyhat.com:8080"
paa_results = scrape_paa("python tutorial", proxy, max_depth=3)

for item in paa_results[:5]:
    print(f"[Depth {item['depth']}] {item['question']}")
    for src in item.get("sources", []):
        print(f"  Kaynak: {src}")

Bu kod, her PAA sorusunu tıklar, açılan alt soruları toplar ve her sorunun cite edilen kaynak URL'lerini çıkarır. 3 derinlik seviyesinde, bir anahtar kelimeden 20-40 benzersiz soru toplanabilir.

Async Playwright ile Paralel PAA Kazıma

Birden fazla anahtar kelime için PAA toplamak gerektiğinde, async Playwright ile paralel tarayıcı seansları açabilirsiniz:

import asyncio
from playwright.async_api import async_playwright

async def scrape_paa_async(keyword: str, proxy_url: str, max_depth: int = 2):
    """Async PAA kazıma."""
    questions = []
    seen = set()
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={"server": proxy_url}
        )
        page = await browser.new_page()
        await page.goto(f"https://www.google.com/search?q={keyword}")
        await page.wait_for_selector("div[jsname]", timeout=15000)
        
        for depth in range(max_depth):
            blocks = await page.query_selector_all('div[jsname="Cpkphb"]')
            for block in blocks:
                q_elem = await block.query_selector('div[jsname="pkPHb"]')
                if not q_elem:
                    continue
                question = await q_elem.inner_text()
                question = question.strip()
                if question in seen:
                    continue
                seen.add(question)
                
                try:
                    await block.click()
                    await page.wait_for_timeout(800)
                except:
                    continue
                
                questions.append({"question": question, "depth": depth})
        
        await browser.close()
    
    return questions

async def batch_paa(keywords: list[str], proxy_template: str):
    """Birden fazla anahtar kelime için paralel PAA kazıma."""
    tasks = []
    for i, kw in enumerate(keywords):
        # Her anahtar kelime için farklı session
        proxy = proxy_template.replace("SESSION", f"sess{i:04d}")
        tasks.append(scrape_paa_async(kw, proxy, max_depth=2))
    
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# 5 anahtar kelimeyi paralel olarak kazı
proxy_template = "http://user-country-US-session-SESSION:pass@gate.proxyhat.com:8080"
keywords = ["python tutorial", "python vs java", "python web dev", "python data", "python ai"]
all_paa = asyncio.run(batch_paa(keywords, proxy_template))

for kw, result in zip(keywords, all_paa):
    if isinstance(result, Exception):
        print(f"Hata ({kw}): {result}")
    else:
        print(f"{kw}: {len(result)} PAA sorusu")

Her anahtar kelime için ayrı bir session ID kullanmak, ProxyHat'ın her tarayıcı seansına farklı bir residential IP atamasını sağlar. Bu, paralel kazıma sırasında IP çakışmasını ve engellenmeyi önler.

Dedup, Kümeleme ve CSV Export

Topladığınız yüzlerce öneriyi ve PAA sorusunu işlenebilir hale getirmeniz gerekir. Aşağıdaki kod, tekrarları kaldırır, arama niyetine göre kümeler ve CSV'ye yazar:

import csv
from collections import defaultdict

def cluster_by_intent(keywords: list[str]) -> dict[str, list[str]]:
    """Anahtar kelimeleri arama niyetine göre kümele."""
    clusters = defaultdict(list)
    for kw in keywords:
        kw_lower = kw.lower().strip()
        if kw_lower.startswith(("how to", "why", "what is", "when", "who")):
            clusters["informational"].append(kw)
        elif kw_lower.startswith(("best", "top", "review")) or " vs " in kw_lower:
            clusters["commercial"].append(kw)
        elif any(w in kw_lower for w in ["buy", "price", "cheap", "deal", "discount"]):
            clusters["transactional"].append(kw)
        elif kw_lower.startswith(("download", "install", "free")):
            clusters["navigational"].append(kw)
        else:
            clusters["general"].append(kw)
    return dict(clusters)

def export_to_csv(keywords: list[str], paa_questions: list[dict], filename: str):
    """Tüm verileri CSV'ye yaz."""
    all_keywords = list(set(keywords))
    clusters = cluster_by_intent(all_keywords)
    
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["type", "keyword", "intent", "word_count", "source"])
        
        # Autocomplete önerileri
        for cluster_name, kws in clusters.items():
            for kw in sorted(kws):
                writer.writerow([
                    "autocomplete", kw, cluster_name,
                    len(kw.split()), "google_autocomplete"
                ])
        
        # PAA soruları
        for item in paa_questions:
            writer.writerow([
                "paa", item["question"], "informational",
                len(item["question"].split()), "google_paa"
            ])
    
    logger.info(f"Exported {len(all_keywords)} autocomplete + "
                f"{len(paa_questions)} PAA to {filename}")

# Toplanan verileri CSV'ye aktar
export_to_csv(results, paa_results, "keyword_research.csv")

CSV çıktısı, içerik ekibiniz için doğrudan kullanılabilir bir tablo verir: her satırda anahtar kelime, niyet kümesi, kelime sayısı ve kaynak. SERP tracking ve web scraping use-case sayfalarımızda bu verileri nasıl iş akışlarına entegre edeceğinizi öğrenebilirsiniz.

Etik ve Hukuki Açıklar

Google'ın autocomplete ve PAA verileri herkese açıktır, ancak bu verileri toplarken bazı kurallara uymanız gerekir:

• Hız sınırlamasına saygı gösterin: İstekler arasında en az 1-2 saniye bekleme koyun. Proxy rotasyonu hızınızı artırsa da, her IP için nazik olun.
• robots.txt'i kontrol edin: Google'ın robots.txt dosyası, hangi yolların taranabilir olduğunu belirtir. suggestqueries.google.com için özel kısıtlamalar olabilir.
• Önce resmi API'leri deneyin: Ölçekli veri toplama için Google Custom Search API veya Google Trends gibi resmi araçları tercih edin. Bu rehber, düşük hacimli araştırma amaçlıdır.
• Kullanıcı şartlarını okuyun: Google'ın Hizmet Şartları, otomatik erişim ile ilgili bölümler içerir. Ticari bir araç inşa ediyorsanız hukuki danışmanlık alın.
• GDPR ve CCPA uyumu: Topladığınız veriler kişisel veri içermese de, Avrupa ve Kaliforniya kullanıcıları için içerik oluştururken bu düzenlemeleri göz önünde bulundurun.

Daha fazla proxy yapılandırma detayı için ProxyHat dokümantasyonunu inceleyebilirsiniz.

Key Takeaways

Özetle:

• Google autocomplete, PAA ve Related Searches, gerçek kullanıcı sorgularını yansıtan üç ücretsiz veri kaynağıdır.
• A-Z ve modifikatör genişletme ile tek bir tohum kelimeden 500-1,000+ öneri toplanabilir.
• PAA accordion yapısı, Playwright gibi headless browser ile tıklanarak iç içe sorular çıkarılabilir.
• Residential proxy ve ülke/şehir bazlı geo-targeting, doğru lokal öneriler almanın anahtarıdır.
• Proxy rotasyonu ile 5 paralel worker, kazıma süresini 5 kata kadar kısaltabilir.
• Toplanan veriler niyet kümesine göre ayrılıp CSV'ye aktarılabilir ve içerik planlamasında kullanılabilir.
• Etik kurallara uyun: hız sınırlarına saygı gösterin, resmi API'leri tercih edin ve robots.txt'i kontrol edin.