Google Trends Compare More Than 5 Keywords

Google Trends compares at most 5 keywords at a time, and every comparison has its own 0-100 scale. This Actor puts your whole keyword list on one 0-100 scale, so you can rank and sort hundreds of keywords and compare a niche term with a head term in one table. Or it returns every keyword on its own scale with interest by region and related queries.

What you get

• One scale for the whole list (scaleMode: oneScale): interest over time for every keyword, where 100 is the peak of the strongest keyword in your list. Each row carries errorPct, the error bound of its value on the shared scale, and linkedVia, the keyword it was measured against.
• Separate (scaleMode: separate): every keyword on its own 0-100 scale, like typing it alone into Google Trends, with interest by sub-region and top and rising related queries.
• Groups of 5 (scaleMode: groupsOf5): like the Compare button, five keywords at a time on one scale.
• Any country or US state, any period from the past hour to all time, web, YouTube, News, Images or Google Shopping search, any Google Trends category.
• You pay only for rows with data (ok and low_precision; in One scale only rows placed on the shared scale with a bound up to 100%). Every other row comes back with its status and is not charged.

How to compare more than 5 keywords in Google Trends

The usual trick is to repeat one anchor keyword in every batch of 5 and rescale. It breaks on the long tail: Google returns whole numbers from 0 to 100, so a keyword 200 times smaller than the anchor becomes 0. We measured it on 02.11.2026 on 400 random real search queries (Google autocomplete, United States, past 12 months): 348 of them have data in Google Trends, and next to the anchor "weather" 341 of those 348 became zero; next to the smaller anchor "yoga mat", 222 of 348.

This Actor builds a ladder of anchors from your own list instead: every keyword is measured next to a keyword of similar size, and the steps are chained up to the strongest keyword. On the same 400 queries:

result	keywords
on the shared scale, ok (bound up to 25%)	157
on the shared scale, low_precision (bound 25-100%)	96
on the shared scale, rough (bound over 100%, not charged)	74
has data, but 0 next to every keyword it could be compared with, below_floor (not charged)	3
has data, but the ladder did not link it, unlinked (not charged)	19
far above the rest, out_of_range (not charged)	2
no search interest, no_data (not charged)	49

It took 479 Google comparisons for 400 keywords, 1.2 per keyword. Random autocomplete queries are a very spread list: the strongest and the weakest keyword on the scale differ by more than 200,000 times, and keywords with no neighbour of similar size in the list get coarse steps, which is why 74 of them are rough.

We checked the shared scale against Google itself on the pairs that Google can compare directly in one request (keywords less than about 200 times apart). Among the charged rows (ok and low_precision), in 270 such pairs the ratio of two keywords on the shared scale differed from Google's direct comparison by 1.5% at the median and by at most 12.4% for 90% of the pairs; all 270 were within the sum of their errorPct. Pairs far apart in size cannot be checked this way, because Google rounds the smaller one to 0; for them only the bound in errorPct is available. The bound is a worst case: typical errors are much smaller.

Statuses

status	what it means	charged
ok	One scale: on the shared scale, error bound up to 25%. Separate and Groups of 5: the keyword has data	yes
low_precision	One scale only: on the shared scale, error bound 25-100%	yes
rough	on the shared scale, but the bound is over 100%: the value can be off several times	no
below_floor	has data, but was 0 next to every keyword of your list it could be compared with; its own 0-100 series is in ownSeries, the upper bound of its average in averageBelow	no
unlinked	has data, but the ladder ran out of steps before linking it; own series in ownSeries; run it again in a shorter list	no
out_of_range	far bigger than the rest of the list; own series in ownSeries, lower bound in averageAbove	no
no_data	Google has no search interest for it	no
zero_in_group	Groups of 5 only: 0 next to a much stronger keyword of its group, it may still have interest on its own	no
failed	One scale only: Google did not answer after retries, so the keyword got no place on the scale	no
error	Separate and Groups of 5: Google did not answer after retries (errorKind, error); or the keyword was rejected as too long	no
skipped	Google started refusing the run's requests and the run stopped asking it, so the keyword was not requested	no
not_processed	the run stopped first (timeout, your maximum cost per run, maxItems)	no

errorPct is a worst-case bound, not a typical error: the sum, over the chain of anchors between the keyword and the strongest keyword, of the rounding error of each link plus 1% of Google's sampling noise per link. The ratio of any two rows is off by at most the sum of their errorPct.

Gaps in your list make it coarse. If nothing in your list sits between a big and a small keyword, the step between them is coarse and the bound grows, up to rough; keywords far below everything else end as below_floor. Adding a few keywords of in-between size makes the ladder precise.

How to use it

1. Put your keywords into Keywords, one per line (or comma separated).
2. Choose Scale: One scale for the whole list, Separate, or Groups of 5.
3. Pick countries or regions (US, GB, US-CA, or WORLDWIDE), the period and the search type.
4. Run. Rows appear in the dataset; the overview table shows average, error bound, peak and latest value.

Input field names of other Google Trends Actors are also accepted: searchTerms, keyword, geo (a single code; empty means worldwide), timeRange, timeframe, category, property, isMultiple, compareKeywords, dataTypes and Google Trends explore links in startUrls. Fields of another Actor that this one does not have are ignored.

How long it takes

Measured on Apify on 02.11.2026 with the default 256 MB memory, United States, past 12 months, random real search queries (the 300-keyword run used the built-in Apify residential proxy, the others a residential proxy given in proxyConfiguration):

mode	keywords	run time
One scale	100	1 minute
One scale	300	4 minutes
One scale	2,000	18 minutes
Separate	50	23 seconds

The ladder makes at most 16 steps. On the 2,000-keyword list 1,284 keywords were charged (ok and low_precision), 220 more ended on the scale as rough, 252 had no data, and 226 were still not linked after the last step: they come back as unlinked with their own series (not charged). Set the run timeout with room to spare: in One scale mode a ladder cut by the timeout returns nothing on the scale.

Example output

One scale (oneScale), one row per keyword and region, from a run of 100 keywords on 02.11.2026 (the series is cut to two points here):

{
  "keyword": "espresso machine for sale",
  "geo": "US",
  "timeframe": "today 12-m",
  "searchType": "web",
  "category": 0,
  "scaleMode": "oneScale",
  "status": "ok",
  "average": 1.245,
  "errorPct": 20.3,
  "peak": {"date": "2025-11-23T00:00:00Z", "value": 2.867},
  "latest": 0.4859,
  "linkedVia": "lawyer landman",
  "interestOverTime": [
    {"date": "2025-11-02T00:00:00Z", "value": 0.8747, "partial": false},
    {"date": "2025-11-09T00:00:00Z", "value": 0.9233, "partial": false}
  ],
  "scrapedAt": "2026-11-02T09:15:24Z"
}

Values are on the scale of your list, so a tail keyword can have an average like 0.0123 while the strongest keyword peaks at 100. Values are kept to 4 significant digits.

Separate (separate) rows have interestOverTime with whole numbers 0-100, average, peak, latest, regions (sub-region, value) and relatedQueries (top and rising, rising with Google's label such as "Breakout").

Pricing

Pay per event: one keyword event for every keyword and region row with status ok or low_precision.

plan	price per keyword with data
Free	$0.004
Bronze	$0.003
Silver and above	$0.0025

No start fee. Proxies are included.

Google Trends API for developers

Python, with the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("firsthand/google-trends-keyword-scraper").call(run_input={
    "keywords": ["air fryer", "standing desk", "yoga mat", "dash cam", "ring light", "massage gun"],
    "scaleMode": "oneScale",
    "geos": ["US"],
    "period": "today 12-m",
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["keyword"], row["status"], row.get("average"), row.get("errorPct"))

Good to know

• Not search counts. Google Trends gives relative interest, never the number of searches. One scale makes keywords comparable with each other, it does not turn them into volumes.
• Google samples. In 8 repeats of the same comparison the average of a keyword varied by up to 3.6% (coefficient of variation 0.2-1.7%).
• One scale is per region and period. With several countries each gets its own ladder and its own 100.
• Regions and related queries come only in Separate and Groups of 5 modes.
• Run timeout. In Separate and Groups of 5 modes rows are saved as they come; if the run is about to time out, the rest is marked not_processed, and a resurrected run with a longer timeout continues without charging saved rows again. In One scale mode the 100 is known only when the whole ladder is done, so a ladder cut by the timeout returns every keyword as not_processed (not charged); run it again with a longer timeout.
• Run summary is in the key-value store record SUMMARY: counts per status, ladder requests and request statistics.
• Terms and data. The Actor reads public Google Trends pages without logging in. Google Trends shows aggregated, anonymized interest, no personal data. Check Google's terms for your use case.