Google Autocomplete API: keyword research with Python

Open Google, start typing, and the search box finishes your sentence. Those suggestions come from what people actually search, which makes them one of the best free sources of keyword ideas. The catch is that you only see about ten at a time, one query at a time.

This guide uses the Google Autocomplete API to collect them at scale. We show what a response looks like, an A-Z sweep that turns one seed into hundreds of suggestions, what four different seeds returned, and a filter that keeps the noise out. Every number below comes from requests we ran in October 2026. Suggestions change over time and by country, so yours will differ.

What a response looks like

Put your key in an environment variable:

export CRAWLERDATA_API_KEY="YOUR_API_KEY"

A request is a POST to https://api.crawlerdata.com/v1/jobs with endpoint set to google-autocomplete:

import os

import requests

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


def suggest(query, country="us", language="en"):
    body = {
        "endpoint": "google-autocomplete",
        "params": {"query": query, "country": country, "language": language},
        "queue": "live",
    }
    resp = requests.post(API_URL, json=body, headers=HEADERS, timeout=120)
    resp.raise_for_status()
    data = resp.json()
    if data["job"]["status"] != "completed":
        raise RuntimeError(data["job"]["error"])
    return [s["value"] for s in data["result"]["suggestions"]]

For the query rank tracker, the result looked like this, trimmed:

{
  "search_parameters": { "engine": "google_autocomplete", "query": "rank tracker", "country": "us", "language": "en" },
  "suggestions": [
    { "value": "rank tracker rocket league", "type": "QUERY" },
    { "value": "rank tracker r6", "type": "QUERY" },
    { "value": "rank tracker fortnite", "type": "QUERY" }
  ]
}

That request returned 15 suggestions, took about 1.3 seconds and cost 1 credit.

Check what your seed really means

Look at the first suggestions for rank tracker again: Rocket League, R6, Fortnite, Valorant, Marvel Rivals. Nearly all of them are video game rank trackers. If you are an SEO tool, that is a warning that the plain phrase belongs to another audience, and that you want seo rank tracker, which completes to:

rank checker seo tool
seo rank tracker free
seo rank tracking
seo rank tracking systems
seo rank checker
seo rank checker free

One cheap request told us which words to use before we spent any time on content. Do this check first for any seed you plan to build on.

The A-Z sweep

A single request gives you about 15 suggestions. To get more, ask for the seed followed by each letter, plus some common prefixes and suffixes, and merge the results:

import string
from concurrent.futures import ThreadPoolExecutor


def sweep(seed, workers=4, **kwargs):
    """Seed plus seed + a..z, plus common prefixes and suffixes. Returns {suggestion: first query that found it}."""
    queries = [seed]
    queries += [f"{seed} {c}" for c in string.ascii_lowercase]
    queries += [f"{p} {seed}" for p in ("how to", "what is", "best", "free")]
    queries += [f"{seed} {w}" for w in ("vs", "alternative", "for", "api")]
    found = {}
    with ThreadPoolExecutor(workers) as pool:
        for q, suggestions in zip(queries, pool.map(lambda q: suggest(q, **kwargs), queries)):
            for s in suggestions:
                found.setdefault(s, q)
    return found, len(queries)

That is 35 requests per seed: the seed, 26 letters, 4 prefixes and 4 suffixes. Four workers run them in parallel. The dictionary remembers which query first produced each suggestion, so you can see which expansion was worth running.

Sort the results into groups with a few lines:

def group(suggestions):
    groups = {"questions": [], "comparisons": [], "other": []}
    for s in suggestions:
        words = s.split()
        if words[0] in {"how", "what", "why", "can", "is", "does", "which", "when"}:
            groups["questions"].append(s)
        elif any(w in words for w in ("vs", "alternative", "alternatives", "versus")):
            groups["comparisons"].append(s)
        else:
            groups["other"].append(s)
    return groups

What four seeds returned

The yield depends on the seed more than on anything else. Each sweep below is the same 35 requests:

A narrow, specific seed gives a short list: seo rank tracker found 43. A broader one gives many more, but the extra suggestions are not always yours. A look at the serp sweep shows why. (Totals move a little between identical runs: the serp sweep found 492 suggestions the first time and 491 when we repeated it.)

Filter the noise

Searches that start with serp also complete to serpentine belt, serpent, serpico, serpentine and serperior. Of the roughly 490 suggestions for that seed, most are not about search. A relevance filter that keeps only suggestions containing a word that makes the topic fixes it:

def keep_relevant(suggestions, must_contain):
    """Drop suggestions that do not mention at least one of the words that make the topic."""
    words = [w.lower() for w in must_contain]
    return [s for s in suggestions if any(w in s.lower() for w in words)]


found, _ = sweep("serp")
kept = keep_relevant(found, ["serp api", "serp tracker", "serp checker", "serp features",
                             "serp analysis", "serp scraper", "serp tool", "serp position",
                             "serp seo", "serp rank", "serp data"])

With that filter, the 491 suggestions from our repeat run became 40 relevant ones, such as:

serp api
serp api key
serp api pricing
serp api status
serp analysis
serp api google
serp checker
serp checker ahrefs
serp checker chrome extension
serp data

Forty good keywords for 35 credits is a better result than 490 mixed ones. The filter is yours to tune: widen the word list for a broader topic, narrow it for a tighter one.

Questions need a different approach. Prefixing a seed with how to produces unnatural phrases that autocomplete does not complete, which is why seo rank tracker found no questions. Ask a real question as the seed instead:

suggest("how to check google rankings")
# -> ['how to check google ranking of website', 'how to check google ranking for my website',
#     'how to check google ranking of keywords', 'how to check google ranking of page', ...]

The first suggestions were all variations on checking rankings. The same trick can mislead: what is a serp completes to what is a serpentine belt and what is a serpent. Always read the first results before you trust a seed.

What to do with the list

Autocomplete tells you what people type, not how often, so it is the start of keyword research, not the end:

1. Sweep each seed and merge the results into one list.
2. Filter for your topic and remove duplicates.
3. Check volumes in a keyword tool and drop what nobody searches.
4. Look at the results. Run the survivors through the Google Search API to see what ranks and which features appear, as in What is a SERP API?.
5. Track what you target with a rank checker.

Country and language

Pass country and language to get the suggestions a searcher in that market sees. country takes one of 31 two-letter codes, such as us, gb, de or jp, and language a two-letter code. Suggestions can differ between markets, so sweep each market you sell in separately.

What it costs

Every request is 1 credit, on every queue. A 35-request sweep is 35 credits.

See pricing for the packs. Failed requests are not charged.

Next steps

You now have a function that collects Google Autocomplete suggestions, a sweep that turns one seed into hundreds, a filter for the noise and a rule for checking a seed before you trust it. The Google Autocomplete API page lists every parameter with a full example response. If you are building rankings tracking on the keywords you find, Rank tracking API is the next step.