Google Search related searches

`relatedSearches` returns the suggested follow-on queries with their search URLs, a source of long-tail variants and modifiers for keyword research.

Returned in result

Request

curl -X POST "https://api.answerline.dev/v1/monitor/google" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"project management software","country":"US","include":{"aioverview":{"markdown":true}}}'

What related searches are

Related searches are the follow-on queries Google suggests for a search, usually shown near the bottom of the results page. They are Google’s view of where searchers go next: narrower versions of the query, common modifiers, adjacent products and alternative phrasings.

result.relatedSearches returns them as query text plus the Google search URL. They expand a few seeds into long-tail variants, surface modifiers that recur across a topic (“for beginners”, “vs”, “near me”, a year) to build pages around, map topic structure through the suggestions seeds share, and supply searcher phrasings for AI visibility prompt sets.

Field reference

result.relatedSearches[]

relatedSearches is always present in a Google Search result as an array. It is read from the first results page.

Annotated excerpt

Values are illustrative; names and types follow the POST /v1/monitor/google result schema.

{
  "result": {
    "relatedSearches": [
      {
        "query": "espresso machine for beginners",
        "link": "https://www.google.com/search?q=espresso+machine+for+beginners"
      },
      {
        "query": "espresso machine with grinder",
        "link": "https://www.google.com/search?q=espresso+machine+with+grinder"
      }
      // Empty array, not a missing key, when the page has no suggestions.
    ]
  }
}

Use query as the input for the next request. link is useful for audit trails and manual checks; there is no need to fetch it.

Cost

No include flag is needed. Related searches come with every Google Search request at the base price: $0.00103 for one page. Keep pages at 1 for expansion work; deeper pages add organic results, not suggestions, and each extra page costs $0.00071.

Expansion multiplies requests. A two-level run from 20 seeds that each return 8 new suggestions is 20 + 160 = 180 tasks, or $0.1854 at $0.00103 each. Deduplicating suggestions across seeds before the second level reduces that, which is why the example does it.

Example: two-level expansion with modifier mining

The script expands seeds one level, deduplicates, expands the new queries once more, then reports the modifiers (words added to a seed) that recur most and the suggestions reached from several seeds.

import os
import re
import time
from collections import Counter, defaultdict
from datetime import date

import requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
SEEDS = ["espresso machine", "coffee grinder", "milk frother"]
MAX_SECOND_LEVEL = 40          # budget guard: at most 40 extra tasks
DAY = date.today().isoformat()


def run_tasks(tasks):
    resp = requests.post(f"{API}/v1/async/task/batch", headers=HEADERS, json=tasks, timeout=60)
    resp.raise_for_status()
    pending = {item["task"]["id"]: tasks[item["index"]] for item in resp.json()["results"] if item["success"]}
    done = []
    while pending:
        time.sleep(10)
        for task_id in list(pending):
            body = requests.get(f"{API}/v1/async/task/{task_id}", headers=HEADERS, timeout=30).json()
            if body["task"]["status"] in ("COMPLETED", "FAILED"):
                task = pending.pop(task_id)
                if body["task"]["status"] == "COMPLETED":
                    done.append((task["payload"]["query"], body["response"]["result"]))
    return done


def norm(text):
    return re.sub(r"\s+", " ", text.lower()).strip()


def expand(queries, level):
    tasks = [
        {"taskType": "GOOGLE", "payload": {"query": q, "country": "US"}, "idempotencyKey": f"rel-{level}-{norm(q)}-{DAY}"}
        for q in queries
    ]
    return {query: [norm(r["query"]) for r in result["relatedSearches"]] for query, result in run_tasks(tasks)}


parents = defaultdict(set)     # suggestion -> queries that suggested it
level1 = expand(SEEDS, 1)
for query, suggestions in level1.items():
    for s in suggestions:
        parents[s].add(query)

seen = {norm(s) for s in SEEDS}
next_level = [s for s in parents if s not in seen][:MAX_SECOND_LEVEL]
seen.update(next_level)
for query, suggestions in expand(next_level, 2).items():
    for s in suggestions:
        parents[s].add(query)

modifiers = Counter()
for suggestion in parents:
    for seed in SEEDS:
        if suggestion.startswith(norm(seed) + " "):
            modifiers[suggestion[len(seed) + 1:]] += 1

print(f"{len(parents)} unique suggestions from {len(SEEDS)} seeds")
print("Most common modifiers:", modifiers.most_common(15))
print("Suggested from 2+ queries:")
for suggestion, sources in sorted(parents.items(), key=lambda kv: -len(kv[1])):
    if len(sources) > 1:
        print(f"  [{len(sources)}] {suggestion}")

The idempotency key includes the normalized query and the day, so rerunning the script the same day cannot run and charge the same query twice.

Pitfalls

Related searches differ by market, language and time. Store the date and country with every suggestion, and compare runs from the same market.

Each level multiplies requests. Cap the queries per level, deduplicate across seeds, and stop once new levels mostly return queries you have already seen.

Case and whitespace differences create false “new” suggestions. The example lowercases and collapses spaces; add rules for plurals or word order if your keyword tool treats them as one.

Some queries return no suggestions, and relatedSearches is then an empty array.

A related search shows association, not demand. Pair the list with a volume source before prioritizing.

Idempotency keys are unique across your account, so a same-day rerun gets RESOURCE_ALREADY_EXISTS for each batch item and creates nothing. Store results as they arrive instead of relying on a rerun to fetch them again.

Related

• Keyword research and People Also Ask keyword research.
• People Also Ask for full questions and who answers them.
• ChatGPT sources: the pages an AI assistant cites for the same question, a complementary view of the topic.
• Idempotency keys explained and rank tracking pipelines with batches.
• Google Search engine guide for targeting, batches and billing.

More Google Search data

All Google Search fields · API reference