How to Scrape Google Search Results with Python + Mobile Proxies (2026)

# Create virtual environment
python -m venv google-scraper
source google-scraper/bin/activate

# Install Playwright and browser
pip install playwright
playwright install chromium

# Optional: for advanced parsing
pip install parsel

import asyncio
from playwright.async_api import async_playwright

async def scrape_google(query: str, proxy_url: str):
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            proxy={"server": proxy_url},
            headless=True,
        )
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                       "AppleWebKit/537.36 (KHTML, like Gecko) "
                       "Chrome/131.0.0.0 Safari/537.36",
        )
        page = await context.new_page()
        await page.goto(
            f"https://www.google.com/search?q={query}",
            wait_until="domcontentloaded",
        )
        await page.wait_for_timeout(2000)

        results = await page.query_selector_all("div.g")
        data = []
        for r in results:
            title_el = await r.query_selector("h3")
            link_el = await r.query_selector("a")
            snippet_el = await r.query_selector("div[data-sncf]")
            if title_el and link_el:
                title = await title_el.inner_text()
                link = await link_el.get_attribute("href")
                snippet = (
                    await snippet_el.inner_text() if snippet_el else ""
                )
                data.append({
                    "title": title,
                    "url": link,
                    "snippet": snippet,
                })

        await browser.close()
        return data

# Usage with proxies.sx mobile proxy
results = asyncio.run(scrape_google(
    "best mobile proxies 2026",
    "http://user_abc123:pass456@138.201.158.43:8522"
))
for r in results:
    print(f"{r['title']}: {r['url']}")

import random
import asyncio

PROXIES = [
    "http://user1:pass1@138.201.158.43:8522",
    "http://user2:pass2@138.201.158.43:8523",
    "http://user3:pass3@62.30.207.124:8002",
]

async def scrape_with_rotation(queries: list[str]):
    results = {}
    for query in queries:
        proxy = random.choice(PROXIES)
        try:
            data = await scrape_google(query, proxy)
            results[query] = data
        except Exception as e:
            print(f"Failed {query} with {proxy}: {e}")
        await asyncio.sleep(random.uniform(3, 8))
    return results

# Example: scrape multiple keywords
keywords = [
    "best mobile proxies 2026",
    "web scraping tools python",
    "serp api alternative",
    "google search scraper",
]

all_results = asyncio.run(scrape_with_rotation(keywords))
for keyword, serps in all_results.items():
    print(f"\n--- {keyword} ---")
    for r in serps:
        print(f"  {r['title']}: {r['url']}")

import asyncio
import random

async def scrape_with_backoff(query: str, proxies: list[str], max_retries: int = 3):
    """Scrape Google with exponential backoff on failure."""
    for attempt in range(max_retries):
        proxy = proxies[attempt % len(proxies)]
        try:
            data = await scrape_google(query, proxy)
            if data:  # Got results
                return data
            # Empty results likely means CAPTCHA page
            raise Exception("Empty results — likely CAPTCHA")
        except Exception as e:
            wait = (2 ** attempt) * 15 + random.uniform(0, 10)
            print(f"Attempt {attempt+1} failed: {e}")
            print(f"Waiting {wait:.1f}s before retry...")
            await asyncio.sleep(wait)

    print(f"All {max_retries} attempts failed for: {query}")
    return None