2026-09-16, updated 2026-11-11, Keyword Research · Google

People Also Ask for keyword research and SEO

People Also Ask (PAA) is the expandable box of related questions Google shows on many results pages. Each entry is a question searchers ask around your query, together with the page or AI-generated answer Google chose for it. Collected across a keyword list, PAA gives you three things keyword volume tools lack: the questions in searchers’ phrasing, who currently owns each answer, and how often Google answers the topic with generated text instead of a link.

This post covers both halves of the job. First, research: extracting PAA as typed data, expanding it level by level and clustering it. Then SEO: mapping clusters to intent, deciding page or section, reading answer owners, and setting a refresh cadence. The field itself is documented on the People Also Ask feature page.

Definitions

• People Also Ask entry: one question in the PAA box, returned as peopleAlsoAsk[].question, with Google’s chosen answer source.
• Answer type: LINK (a web page answers it, with title, link, snippet), AIOVERVIEW (an AI-generated overview answers it) or UNKNOWN.
• Answer owner: the domain in link for a LINK entry, or the domains in sources[] for a hydrated AIOVERVIEW entry.
• PAA expansion: running the questions returned for one query as new queries, to collect the next level of questions.
• Question cluster: a group of PAA questions that one page can answer.
• AI answer share: the share of PAA entries in a set of results whose type is AIOVERVIEW.
• Owner concentration: the share of LINK answers in a cluster held by the single most frequent domain.

Google’s own name for the block is a “related questions group”, described in its visual elements gallery as “a cluster of questions related to the user’s initial search” (checked 2026-09-17).

The data

A Google Search request returns PAA as a typed array, with the rest of the page.

curl -X POST https://api.answerline.dev/v1/monitor/google \
  -H "Authorization: Bearer $ANSWERLINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "query": "iphone 17 vs galaxy s26", "country": "US" }'

{
  "success": true,
  "result": {
    "organicResults": [ { "position": 1, "title": "…", "link": "…", "snippet": "…" } ],
    "peopleAlsoAsk": [
      { "question": "Is the iPhone 17 better than the Galaxy S26?", "type": "LINK", "title": "…", "link": "…", "snippet": "…" },
      { "question": "Which phone has better battery life?", "type": "AIOVERVIEW" }
    ],
    "relatedSearches": [ { "query": "…", "link": "…" } ]
  }
}

The questions above are placeholders; your output depends on the query and market.

Field reference

Two other arrays in the same response feed keyword research: relatedSearches[] (query, link) and, when Google shows the module, peopleAreSaying[] (position, title, link, date), which often points at forum threads.

Targeting

The request takes query plus country (or gl), and location or uule for a city. Collect each market you publish for separately. For local nuances, see local rank tracking.

Building the question map

1. Seed set

Pick 20 to 100 head terms per topic area: product category terms, comparison pairs, and the problems your product solves. Seeds you already rank for are useful too, because their PAA shows the follow-up questions your page does not yet answer.

2. Expand level by level

Run the seeds, collect every question, deduplicate, and run the new questions as the next level. Stop when a level adds few questions you have not seen, or at a fixed depth of two or three. The code below does this with async tasks.

import os
import re
import time
from collections import Counter, defaultdict
from urllib.parse import urlparse

import requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['ANSWERLINE_API_KEY']}"}
COUNTRY = "US"

def norm(q):
    return re.sub(r"[^a-z0-9 ]", "", q.lower()).strip()

def run_level(queries, level):
    tasks = [
        {
            "taskType": "GOOGLE",
            "payload": {"query": q, "country": COUNTRY},
            "idempotencyKey": f"paa-{COUNTRY}-{level}-{norm(q)[:80].replace(' ', '-')}",
        }
        for q in queries
    ]
    ids = []
    for i in range(0, len(tasks), 500):  # batch limit is 500 tasks
        r = requests.post(f"{API}/v1/async/task/batch", json=tasks[i:i + 500], headers=HEADERS, timeout=60)
        r.raise_for_status()
        ids += [x["task"]["id"] for x in r.json()["results"] if x["success"]]
    done = {}
    while len(done) < len(ids):
        for tid in ids:
            if tid not in done:
                d = requests.get(f"{API}/v1/async/task/{tid}", headers=HEADERS, timeout=30).json()
                if d["task"]["status"] in ("COMPLETED", "FAILED"):
                    done[tid] = d
        time.sleep(10)
    return [d["response"]["result"] for d in done.values() if d["task"]["status"] == "COMPLETED"]

seen = set()
frequency = Counter()          # how many collected SERPs showed the question
owners = defaultdict(Counter)  # question -> answering domains
frontier = ["iphone 17 vs galaxy s26", "best android phone for photography"]

for level in range(3):
    seen |= {norm(q) for q in frontier}
    results = run_level(frontier, level)
    new = {}
    for result in results:
        for paa in result.get("peopleAlsoAsk", []):
            key = norm(paa["question"])
            frequency[key] += 1
            if paa.get("type") == "LINK" and paa.get("link"):
                owners[key][urlparse(paa["link"]).hostname] += 1
            if key not in seen:
                new[key] = paa["question"]
    print(f"level {level}: {len(results)} SERPs, {len(new)} new questions")
    if len(new) < 10:
        break
    frontier = list(new.values())

Idempotency keys built from market, level and normalized question make a re-run of the same script safe: a question already submitted is not charged again. Keep keys short; the example truncates the normalized question. For large runs, add a webhook to each task instead of polling; see async tasks and webhooks.

3. Cluster

Group questions that one page can answer. Start simple and refine by hand:

1. Normalize (lowercase, strip punctuation, as norm does).
2. Group by the entity pair or head noun (“battery life”, “camera”, “price”).
3. Merge near-duplicates (“is X better than Y”, “which is better X or Y”).
4. Order clusters by summed frequency: a question that appears on many of the results pages you collected is central to the topic.

frequency measures centrality within your own collection, not search volume; pair it with volume data from your keyword tool if you have it.

From clusters to content

Map questions to intent

A PAA list mixes intents. Sorting questions by what the searcher is trying to do tells you what kind of content answers them and where it belongs.

A simple rule-based classifier on the first words of each question sorts most of a list; review the rest by hand. Intent matters more than wording: “Is a standing desk worth it” and “Are standing desks good for you” are both evaluation questions and usually belong on the same page.

Page or section?

Decide per cluster, not per question:

1. Own page when the cluster has several distinct sub-questions, shows up across many of your seed queries, and its current owners are dedicated pages.
2. Section on an existing page when the questions are follow-ups to a topic you already cover, and the owners are sections of longer pages.
3. FAQ block for short factual questions (eligibility, limits, yes or no) that do not justify a heading of their own.
4. Skip when the intent does not match what you sell or know, even if the question is popular.

FAQ sections without the rich-result assumption

One PAA tactic was to add an FAQ section with FAQPage markup and hope for an FAQ rich result. That no longer applies. Google’s documentation changelog records that in September 2023 the FAQ documentation was updated to say the feature is only shown for well-known, authoritative government and health websites, and a May 2026 entry adds a deprecation notice because “this feature will no longer appear in Google Search starting May 7, 2026” (Latest Google Search documentation updates, checked 2026-09-17).

FAQ sections are still worth writing when they help readers, because the structure itself answers PAA questions cleanly:

• Use the PAA question, or a close natural variant, as the heading.
• Put the direct answer in the first sentence under it. Qualifications come after.
• Keep one question per heading. Merged questions produce vague answers.
• Answer only what you can answer accurately. Google’s guidance on helpful content says content made “primarily to attract search engine visits” is “not aligned with what our systems seek to reward” (checked 2026-09-17).

Do not pad pages with every PAA question you collected. A focused page that answers its cluster completely is more useful than a long page that touches forty loosely related questions.

Read the answer owners

The owner of a PAA answer is the page you need to beat, and the pattern of owners across a cluster tells you how hard that is. For each cluster, compute owner concentration, the owner type mix (publishers, brands, forums, government sites, marketplaces), your share of answers, and how often each question’s owner changed between runs. Then read the pattern:

Look at the owning pages before you brief a writer. The snippet on a LINK entry shows the passage Google showed for that question, a practical hint about the answer length and format that currently wins.

Each brief then follows from the cluster: the most frequent question as the heading, the other questions as subheadings or an FAQ, the current owners as the pages to beat, and the direct answer in the first sentence under each heading.

AIOVERVIEW versus LINK share

Measured over a cluster and over time, the split of type values says how a topic is answered in your results.

• Mostly LINK: questions are answered by individual pages. Classic on-page work applies: the right heading, a direct answer, a strong page.
• Mostly AIOVERVIEW: questions are answered by generated text built from several sources. There is no single slot to win; the goal is to be among the cited sources[], consistently.
• Rising AIOVERVIEW share: a topic moving from links to generated answers. Report it early; it changes what “owning” the question means for your team.

Two cautions apply. The share describes your own queries and markets, not Google as a whole. And without include.paaAioverview an AIOVERVIEW entry has no answer data, so it looks ownerless; hydrate at least a sample before calling a cluster an easy win.

Google’s documentation on AI features says pages need to be indexed and eligible to be shown with a snippet to appear in AI Overviews, and that “there are no additional requirements” (AI features and your website, checked 2026-09-17). So the page-level work for AIOVERVIEW clusters is the same as for LINK clusters; what changes is how you measure success. How AI engines choose citations and featured snippets and AI Overviews go further.

A cluster report

Compute the signals above from stored results:

from collections import Counter, defaultdict
from urllib.parse import urlsplit

def host(url):
    return (urlsplit(url or "").hostname or "").lower().removeprefix("www.")

def cluster_report(results: list[dict], cluster_of, my_domain: str) -> dict:
    """results: stored `result` objects; cluster_of: function mapping a question to a cluster name."""
    types = defaultdict(Counter)
    owners = defaultdict(Counter)
    cited = defaultdict(Counter)
    for result in results:
        for item in result.get("peopleAlsoAsk") or []:
            c = cluster_of(item["question"])
            types[c][item.get("type", "UNKNOWN")] += 1
            if item.get("type") == "LINK" and item.get("link"):
                owners[c][host(item["link"])] += 1
            for s in item.get("sources") or []:
                cited[c][host(s["url"])] += 1
    report = {}
    for c, t in types.items():
        links = sum(owners[c].values())
        top = owners[c].most_common(1)
        report[c] = {
            "items": sum(t.values()),
            "ai_answer_share": round(t["AIOVERVIEW"] / sum(t.values()), 2),
            "owner_concentration": round(top[0][1] / links, 2) if links else None,
            "top_owner": top[0][0] if top else None,
            "my_link_answers": owners[c][my_domain],
            "my_citations": cited[c][my_domain],
        }
    return report

Refresh cadence

PAA lists and owners change. How often to re-run depends on what a change would trigger:

Keep every run comparable: same query text and the same country or gl. Diff each run against the previous one and report three lists: new questions, disappeared questions, and changed owners. Rising questions are early content opportunities. SERP feature change tracking shows the diffing pattern.

Cost

The question counts here are invented; the prices are not (Starter tier). A Google Search task costs $0.0015, and include.paaAioverview is free, so a hydrated task costs the same. With 50 seeds, level 0 costs 50 x $0.0015 = $0.075. If those results yield 180 new unique questions, level 1 costs $0.27. If level 1 yields 400 new questions and you stop at level 2, that level costs $0.60. Total: 630 tasks, $0.945.

Hydration is free but makes responses slower, because each hydrated entry needs one more fetch. Deduplication is the main cost control: without the seen set, the same popular questions come back at every level and get paid for repeatedly.

PAA and AI answers

PAA questions and AI assistant prompts overlap: both are full questions in searchers’ own words. That makes a PAA map a good starting point for an AI monitoring prompt set. Take the top cluster heads, run them as ChatGPT or Gemini prompts, and compare who is cited there against who owns the PAA answer on Google. Where the same domain wins both, you are competing with an entrenched source; where they differ, there is room.

The link does not run the other way through ChatGPT. Its result.searchQueries[] comes back empty on the answers served today, so it gives no seeds to feed back into the expansion above. The cited sources are the signal to compare. See prompt set design and GEO vs SEO metrics.

Pitfalls

• Paying for duplicates. Normalize and deduplicate before every level.
• Treating frequency as search volume. It counts appearances in the results you collected.
• One market for all content. PAA for country: "GB" can differ from the US; collect what you publish for.
• Ignoring AIOVERVIEW entries. Without include.paaAioverview they carry no answer data, so they look ownerless.
• Unbounded depth. Each level can multiply queries. Set a maximum depth and a minimum new-question threshold.
• Padding pages. Answer the cluster, not every question you collected.

Related

For the underlying data model, see typed SERP data, the People Also Ask feature page and the Google Search engine page. Related results on the same page: related searches and “people also search for” and what is a SERP. The use case is described on keyword research; batch mechanics for large keyword sets are in rank tracking with batches.

Start with the quickstart.

Keep reading