Free AnswerThePublic Alternative: PAA + Autocomplete via API

AnswerThePublic was magical the first time you used it. Type a seed keyword, get a tree of every question and prepositional phrase Google's autocomplete had ever suggested for it. Brilliant for content briefs.

Then in 2024 the free tier got squeezed, the pricing got steep, and the tool started gating the most useful outputs behind the highest plan. A lot of teams I work with quietly stopped using it.

Here's the thing — the underlying data is just two public Google surfaces. People Also Ask blocks on the SERP, and Google autocomplete suggestions. A SERP API exposes both, which means you can build your own AnswerThePublic-style explorer in a couple hundred lines of Python, free for 100 queries and very cheap beyond that.

What you get out of this build

By the end of this guide you'll have a Python tool that takes a seed keyword and outputs:

• Direct PAA questions from the SERP.
• Expanded PAA tree — questions that emerge when you "click" one PAA item.
• Related searches — the row of suggestions at the bottom of the SERP.
• Autocomplete suggestions across "seed a", "seed b" ... "seed z" plus prepositions (for, vs, with, without, when, why, how).
• A dedup'd master list ready to import into your content tool of choice.

That's roughly the same dataset AnswerThePublic charges hundreds of dollars a year for, in a CSV you own.

The two data sources, demystified

Source 1: People Also Ask (PAA). The "People Also Ask" block on a Google SERP. Each entry is an actual question Google has decided is related to your query. Click one and it expands to reveal more related questions — an effectively infinite tree if you keep expanding. The Serpent Google SERP API returns the top-level PAA array directly in results.peopleAlsoAsk.

Source 2: Google autocomplete. The dropdown suggestions you see while typing. Google exposes a JSON endpoint at suggestqueries.google.com/complete/search — undocumented, no auth, no rate-limit headers, used by browsers for decades. We'll call it directly because, unlike SERP scraping, autocomplete responses are intentionally machine-readable and there's nothing exotic to defeat.

Together these two cover the same surface that AnswerThePublic visualises. The "questions" wheel comes from PAA + question-starter autocomplete. The "prepositions" wheel comes from preposition-starter autocomplete. The "alphabeticals" come from a-z autocomplete.

Tutorial: build the question explorer

Three files. Total about 120 lines. Save the file, run, get CSV.

1. The PAA fetcher

import os, requests
API_KEY = os.environ["SERPENT_API_KEY"]
URL     = "https://apiserpent.com/api/search"

def fetch_paa(seed, country="us"):
    r = requests.get(URL, params={"q": seed, "num": 20, "country": country},
                     headers={"X-API-Key": API_KEY}, timeout=60)
    r.raise_for_status()
    data = r.json().get("results", {})
    paa = [p.get("question", "") for p in data.get("peopleAlsoAsk", []) if p.get("question")]
    rel = [r.get("query", "") for r in data.get("relatedSearches", []) if r.get("query")]
    return paa, rel

One API call. Returns PAA questions plus related-search phrases. Cost on the Scale tier: about $0.00005 per call.

2. The autocomplete fetcher

import string, urllib.parse, requests

PREPS = ["for","vs","with","without","when","why","how","near",
         "in","on","at","to","best","cheap","alternatives"]
AUTOCOMPLETE = "https://suggestqueries.google.com/complete/search"

def fetch_autocomplete(seed, country="us"):
    out = []
    suffixes = list(string.ascii_lowercase) + PREPS
    for s in suffixes:
        q = f"{seed} {s}"
        r = requests.get(AUTOCOMPLETE, params={
            "client":"firefox", "q": q, "hl":"en", "gl": country
        }, timeout=15)
        try:
            arr = r.json()
            out.extend(arr[1])     # [query, [suggestions], ...]
        except Exception:
            pass
    return sorted(set(out))

Iterates the alphabet plus a list of prepositions and category modifiers. Each request hits Google's autocomplete and grabs the suggestion list. Forty or so requests for a complete sweep — takes about 6 seconds.

3. The main runner

import csv, sys
from paa_fetcher import fetch_paa
from auto_fetcher import fetch_autocomplete

def main(seed):
    paa, related = fetch_paa(seed)
    suggest = fetch_autocomplete(seed)

    rows = [("source","query")]
    rows += [("paa", q) for q in paa]
    rows += [("related", q) for q in related]
    rows += [("autocomplete", q) for q in suggest]

    out = f"questions-{seed.replace(' ','-')}.csv"
    with open(out, "w", newline="") as f:
        csv.writer(f).writerows(rows)
    print(f"wrote {out} | paa={len(paa)} related={len(related)} suggest={len(suggest)}")

if __name__ == "__main__":
    main(" ".join(sys.argv[1:]) or "cheapest serp api")

Run it:

python main.py "best vector database"

You'll get something like:

wrote questions-best-vector-database.csv | paa=8 related=8 suggest=146

A 162-row CSV from a 5-second job. AnswerThePublic gives you the same shape for that seed; you now have it for the cost of one API call plus 40 free autocomplete calls.

Visualising the output

The CSV is the data. The AnswerThePublic-style wheel is a visualisation. Three quick ways to render it:

1. Spreadsheet pivot. Group by source, then by the first word of the query (often a question word: what, how, why, when, who). One pivot table = the question wheel.

2. Mermaid diagram. Programmatically generate a Mermaid mind-map definition from the CSV. Render in any Markdown viewer. The output is shareable and version-controllable.

3. Streamlit app. ~50 lines of Streamlit code wraps the CSV in a clickable explorer. Run locally, deploy to Streamlit Cloud free.

None of the visualisations are technically required — for most content-brief use cases the CSV alone is enough.

Real use cases for the data

This isn't just a cost-cutting move. The question-discovery dataset has uses I didn't fully appreciate until I was running my own:

1. Content brief generation. Feed the CSV plus the seed keyword to your favourite LLM with a "produce a content brief with H2s based on these questions" prompt. The output is usually 80 percent of a brief — better than most paid tools.

2. AEO/GEO targeting. Pages that explicitly answer the PAA questions get cited more in AI Overviews and AI assistants. See our AEO playbook for the full pattern.

3. Keyword cluster discovery. Run the script on five related seeds and merge the CSVs. Cluster by similarity. You'll surface the natural topic clusters in your category — many of them long-tail and unserved. Our cannibalization guide covers the clustering side.

4. Local intent expansion. Run it with country set to your target market. PAA and autocomplete vary by country — "best CRM" in the UK is not "best CRM" in the US. This is one of the most valuable parts of doing it yourself, since most paid tools default to US-only.

5. Competitor query mining. Run it on a competitor's brand. The autocomplete suggestions tell you which questions Google sees most often paired with their name — useful intel.

Scaling beyond 100 queries

Three operational notes for when you want to run this on hundreds or thousands of seeds:

1. Stagger autocomplete requests. Google's autocomplete endpoint is generous but not infinite. A 200ms delay between requests keeps you well below any threshold I've seen.

2. Cache aggressively. PAA and autocomplete for a given seed don't change minute-to-minute. Cache results for 24 hours in Redis or a flat file. Most teams running this at scale re-query weekly, not daily.

3. Use SERP API batching. If you have 500 seeds, fire them in 20 parallel workers against the SERP API. Even on the Default tier you can run all 500 in under a minute. See pricing for tier concurrency limits.

For a related, more end-to-end approach to keyword research using the same API surface, see our SERP API keyword research tutorial.

FAQ

Why not just keep using AnswerThePublic?

You can. This is for teams who'd rather own the pipeline, run it across many countries, or feed the data into other tools without re-paying a subscription per use.

Is the autocomplete endpoint reliable?

It's undocumented but has been stable for over a decade. If it changes, the SERP API alone (PAA + related searches) still gives you most of the AnswerThePublic value.

Can I generate the AnswerThePublic visual wheel automatically?

Yes — render the CSV with D3.js, Plotly, or a Streamlit app. About 80 extra lines of code. The CSV itself is the part that matters.

Does this work for languages other than English?

Yes. Pass language and country parameters to the SERP API call and the matching hl/gl to autocomplete. Results are localised.

How does this compare in cost to AnswerThePublic Pro?

AnswerThePublic Pro is ~$99/month for limited usage. 100 seed keywords / month on Serpent's Scale tier costs about $0.005 in SERP API charges plus zero for autocomplete — roughly four orders of magnitude cheaper at typical volumes.