Perplexity API alternatives — build your own AI search backend.

User query
  │
  ▼
┌─────────────────────────────────────────┐
│ 1. Search step                          │
│    Scrape Google / Bing / etc. for      │
│    top N URLs related to the query      │
│    (via Pool Gateway mobile proxies)    │
└─────────────────────────────────────────┘
  │
  ▼
┌─────────────────────────────────────────┐
│ 2. Content fetch                        │
│    For each URL, fetch the page         │
│    (also via mobile proxies — many      │
│    sites block datacenter scrapers)     │
│    Extract main content with Readability│
└─────────────────────────────────────────┘
  │
  ▼
┌─────────────────────────────────────────┐
│ 3. LLM summarize                        │
│    Send query + sources to Claude/GPT   │
│    Get back: summary + per-citation     │
│    inline references                    │
└─────────────────────────────────────────┘
  │
  ▼
Final response (matches Perplexity output shape)

pip install httpx playwright readability-lxml anthropic
playwright install chromium

import asyncio, os
from urllib.parse import quote_plus
from playwright.async_api import async_playwright

PSX_USER = os.environ['PSX_USERNAME']
PSX_PASS = os.environ['PSX_PASSWORD']

async def search_google(query: str, top_n: int = 5) -> list[str]:
    """Get top N URLs for a query."""
    url = f"https://www.google.com/search?q={quote_plus(query)}&hl=en&num=20"
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={"server": "http://gw.proxies.sx:7000", "username": PSX_USER, "password": PSX_PASS},
        )
        page = await (await browser.new_context()).new_page()
        await page.goto(url, wait_until="networkidle", timeout=30000)
        await page.wait_for_timeout(1500)

        urls = await page.evaluate("""
() => [...document.querySelectorAll('h3')]
  .map(h => h.closest('a'))
  .filter(a => a && a.href.startsWith('http'))
  .map(a => a.href)
  .filter(u => !u.includes('google.com'))
        """)
        await browser.close()
        return list(dict.fromkeys(urls))[:top_n]  # dedup, slice

import httpx
from readability import Document

async def fetch_clean(url: str) -> dict:
    """Fetch URL through mobile proxy, extract main content."""
    proxy_url = f"http://{PSX_USER}:{PSX_PASS}@gw.proxies.sx:7000"
    async with httpx.AsyncClient(proxies=proxy_url, timeout=30, follow_redirects=True) as client:
        try:
            r = await client.get(url, headers={"User-Agent": "Mozilla/5.0 ..."})
            doc = Document(r.text)
            return {
                "url": url,
                "title": doc.title(),
                "content": doc.summary(html_partial=True)[:8000],  # cap context
            }
        except Exception as e:
            return {"url": url, "error": str(e)}

from anthropic import Anthropic

anthropic = Anthropic()

async def ai_search(query: str, top_n: int = 5) -> dict:
    urls = await search_google(query, top_n)
    sources = await asyncio.gather(*[fetch_clean(u) for u in urls])
    sources = [s for s in sources if "content" in s]

    # Build a prompt with numbered citations
    citations_block = "\n\n".join(
        f"[{i+1}] {s['title']}\nURL: {s['url']}\n{s['content']}"
        for i, s in enumerate(sources)
    )

    msg = anthropic.messages.create(
        model="claude-opus-4-7",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Answer the user's question using the provided sources. Cite sources inline as [1], [2], etc.

QUESTION: {query}

SOURCES:
{citations_block}

ANSWER (with inline citations):"""
        }]
    )
    return {
        "query": query,
        "answer": msg.content[0].text,
        "sources": [{"index": i+1, "url": s["url"], "title": s["title"]} for i, s in enumerate(sources)],
    }

# Use it
result = asyncio.run(ai_search("how does CGNAT work"))
print(result)