Google related searches vs autocomplete: how they overlap and how stable they are

When you do keyword research with Google’s own data, three lists show up everywhere: autocomplete, People Also Ask and related searches. Most people treat them as the same thing in different places. We checked how much they actually overlap, starting with the one that gets the least attention, related searches.

We ran 20 seeds through the Google Search API and the Autocomplete API in October 2026 and compared the lists. This guide has the numbers, code to run the comparison on your own seeds, and a note on what to do about the instability. Results change, so yours will differ.

How we ran it

We used 20 seeds: best running shoes, how to learn python, project management software, what is inflation, how to lower blood pressure, best vpn, standing desk, how to start a podcast, best laptop 2026, noise cancelling headphones, how to tie a tie, best credit card, why is the sky blue, how to change a tire, best crm software, what causes headaches, how does a vpn work, how to boil eggs, iphone 16 pro price and best budget phone. For each we made one google-search request and one google-autocomplete request in us. We then repeated the first 6 searches to see how stable the related searches are. That is 46 requests.

It is a small set of seeds we picked, checked once, so the figures describe it and nothing wider.

What a response contains

Related searches come in the related_searches field of every search response, as a list of objects with a query:

"related_searches": [
  { "query": "Best running shoes for road" },
  { "query": "Best running shoes for beginners" },
  { "query": "Best running shoes for asphalt and concrete" }
]

There is no extra cost to read them, since they come with the search. How many did we get? For 18 of the 20 seeds, 8. how to start a podcast returned 3, and best laptop 2026 returned none, so an empty list is a normal result. The 147 related searches we collected averaged 5.6 words, and 139 of the 147 started with a capital letter, unlike autocomplete’s lowercase.

How they differ from autocomplete

Autocomplete finishes what you typed. Related searches are a looser set of nearby ideas:

• 54% of the related searches started with the seed, such as Best running shoes for beginners. The other 46% were rephrasings, such as Example of inflation for the seed what is inflation.
• 41% were in question form, for example How does inflation affect the economy.
• On average each related search added 1.8 new words to the seed.

And they overlap very little with the other lists:

So the three lists are three views. For best vpn, only Best VPN free was in both lists. The related-only ones were Cheapest VPN monthly, Top 10 best VPN in the world, Best VPN 2026 for Android and Best monthly VPN, ideas that autocomplete did not offer. If you collect all three, you get more keywords than any one of them gives you.

Some related searches are out of date

Seven related searches mentioned a year. Three of those named an earlier one:

best running shoes  ->  Best running shoes 2024
best running shoes  ->  Best running shoes for 2025
best budget phone   ->  Best budget phone 2025

The other four said 2026, such as Best VPN 2026 free and Best credit cards 2026 for travel. Autocomplete, by contrast, was almost all current: 24 of its 25 year mentions were 2026.

The practical point: do not treat a related search as a sign that people are searching for it today. A related search is a prompt to check, not a measurement, and one with an old year is probably not worth a page.

Related searches change between runs

We repeated 6 of the searches and compared each related list with the first run:

The average was 5.3 of 8, from all of them to none. For how to lower blood pressure, the first run offered How to lower blood pressure quickly and Three easy exercises to lower blood pressure immediately, and the second offered How to cure high blood pressure in 3 minutes and What to drink to lower blood pressure: a completely different set.

When we later ran how to lower blood pressure twice more in testing the code, the two runs matched. The stability varies from run to run, which is the point. One request is a sample.

The code

Put your key in an environment variable:

export CRAWLERDATA_API_KEY="YOUR_API_KEY"

import os
import time

import requests

API_URL = "https://api.crawlerdata.com/v1/jobs"
HEADERS = {"Authorization": f"Bearer {os.environ['CRAWLERDATA_API_KEY']}"}


def call(endpoint, query, country="us", retries=4):
    body = {"endpoint": endpoint, "params": {"query": query, "country": country}, "queue": "live"}
    for attempt in range(retries):
        resp = requests.post(API_URL, json=body, headers=HEADERS, timeout=180)
        if resp.status_code == 429:
            time.sleep(int(resp.headers.get("retry-after", 10)))
            continue
        resp.raise_for_status()
        job = resp.json()["job"]
        if job["status"] == "completed":
            return resp.json()["result"]
        if "retry" in (job["error"] or "").lower():  # "service is busy" and "temporarily blocked" both say retry
            time.sleep(5 * (attempt + 1))
            continue
        raise RuntimeError(job["error"])
    raise RuntimeError("Request failed after retries")


def norm(text):
    return " ".join(text.lower().split())


def related(query):
    """The related_searches Google shows under the results (may be empty)."""
    return [r["query"] for r in call("google-search", query)["related_searches"]]


def autocomplete(query):
    return [s["value"] for s in call("google-autocomplete", query)["suggestions"]]


def compare_sources(seed):
    rel, auto = related(seed), autocomplete(seed)
    auto_set = {norm(a) for a in auto}
    return {
        "related": len(rel),
        "autocomplete": len(auto),
        "in_both": [r for r in rel if norm(r) in auto_set],
        "only_related": [r for r in rel if norm(r) not in auto_set],
    }


def related_union(seed, runs=2):
    """Related searches seen in any of `runs` requests. Related searches change between runs."""
    seen = {}
    for _ in range(runs):
        for r in related(seed):
            seen.setdefault(norm(r), r)
    return list(seen.values())

For best vpn, compare_sources printed:

8 related | 1 also in autocomplete: ['Best VPN free']
only related: ['Cheapest VPN monthly', 'Top 10 best VPN in the world', 'Best VPN 2026 for Android', 'Best monthly VPN']

related_union makes the requests more than once and keeps everything it saw, so a seed that returns different lists on different runs gives you the combined set. On the one test we ran, both requests happened to return the same 8, so the union was 8. It costs 1 credit per run.

What to do with it

• Collect all three lists. Related searches, autocomplete and People Also Ask overlap very little, so each adds keywords. The autocomplete sweep covers the other two.
• Request important seeds twice or more, and keep the union.
• Check years. Drop related searches that name an old year.
• Handle an empty list. Some seeds return none, and that is not an error.
• Check demand elsewhere. These lists are candidates, not proof of volume.

What it costs

Related searches come with every google-search request, so there is no extra credit for them. Every request is 1 credit, on every queue. Starter is $1.00 per 1,000 requests and the largest pack is $0.30 per 1,000, see pricing.

Failed requests are not charged.

Next steps

You now have numbers on how related searches compare with autocomplete and People Also Ask, a warning about stale years and instability, and code that merges the lists. The Google Search API page lists every parameter with a full example response, and Google Autocomplete by country covers how suggestions change between markets.