Google Trends Scraper – Compare 100 Keywords on One Scale

Google Trends lets you compare only 5 keywords at a time, and every comparison is rescaled to its own 100. This Actor compares up to 100 keywords on one common 0–100 scale, so "50" means the same thing for every keyword in your list. Every run is self-checked against a direct Google Trends query and the error is reported in the output.

$4 per 1,000 keywords. You pay only for keywords that were actually delivered.

Who uses it

• SEO & content agencies: rank 20–100 topic or keyword ideas by real search interest before writing content; compare clients vs. competitors in one chart.
• Marketers & brand managers: track brand vs. competitor interest by country, US state or metro, on Web, YouTube, News or Google Shopping.
• Analysts & researchers: long, comparable time series (2004–today) for 100 terms, ready for Excel, Google Sheets, Python or BI tools.
• E-commerce & product teams: compare product categories or brands on Google Shopping search for a market and season.
• AI agents (MCP) & developers: one API call with just keywords (+ optional geo, timeframe) returns normalized data plus a quality report the agent can check.

Why chaining matters (real example)

Paste several 5-keyword Google Trends exports together and each batch has its own 100, so the numbers can't be compared. In our test with synthetic data of known truth, this naive approach was off by more than 20 index points. With anchor chaining every well-measured keyword stayed within 0.3 points mean absolute error.

Real 100-keyword run (worldwide, last 5 years, 2026-10-18), top of the ranking on the common scale:

Rank	Keyword	Average	Peak
1	chatgpt	38.2	100.0
2	c++	29.4	40.2
3	python	9.4	14.0
4	swift	7.6	25.7
5	github	6.2	27.0
6	java	6.1	8.5

Self-check of that run: 5 keywords measured in 4 different batches (cloudflare, scala, jenkins, typescript, postgresql) were queried directly together. Mean absolute error vs. Google's direct answer: 0.187 points (max 1.01), average-ratio error ≤ 0.37 %.

Measured accuracy and speed (real runs)

Run	Keywords	Requests	Time	Self-check error (mean, 0–100 scale)
US, 12 months, Apify cloud, residential proxy	25	29	36 s	0.59 points ✅
US-CA, 2024, YouTube (local test)	25	25	41 s	0.15 points ✅
Worldwide, last 7 days hourly, News + extras (local test)	6	21	46 s	0.61 points ✅
Worldwide, 5 years (local test)	100	109	3 min 43 s	0.19 points ✅

Features

• 1–100 keywords on one 0–100 scale (100 = the single highest point of any keyword in your list).
• Self-check against a direct Google query + per-keyword precision and consistency metrics.
• Any location: worldwide, country (US, ES, DE…), region (US-CA, ES-MD), US metro (US-NY-501).
• Any period: past hour … 2004–today, or a custom date range.
• Web, News, YouTube, Images, Google Shopping, plus category filter.
• Optional related queries (top & rising) and interest by region.
• CSV / JSON / Excel dataset export + ready-made wide CSV (date × keyword) and summary CSV.
• Fair billing: failed or no-data keywords are free; your max cost per run is respected.
• Safe: hard caps on requests and runtime, bounded retries, clear error messages, no infinite loops.

How it works (anchor chaining)

1. Seed: the first 5 keywords are queried together and a mid-popularity keyword is chosen as the anchor.
2. Star screening: the remaining keywords are queried in groups of 4 + the anchor.
3. Refinement ladders: keywords that are much more or much less popular than the anchor would lose precision (Google rounds to integers, very small values become 0 or <1). They are re-measured in overlapping batches with neighbours of similar magnitude, so every keyword is measured where its values are large and precise.
4. Weighted least-squares solve: one scale factor is estimated for every batch from all shared keywords at once (weighted by rounding precision), so ratios are chained through multiple anchors instead of a single fragile one.
5. Global renormalization: all series are rescaled so the overall maximum is exactly 100.
6. Self-check: up to 5 keywords of similar magnitude that were measured in different batches are queried directly together; the Actor reports mean/max absolute error, average-ratio error and Pearson correlation.

Every keyword also gets consistency metrics: how many batches it appeared in, its best raw peak (precision), the number of <1 points, the scale residual across batches and the cross-batch deviation of its series.

Input example

{
  "keywords": ["python", "javascript", "rust", "golang", "kotlin", "swift", "typescript"],
  "geo": "US",
  "timeframe": "today 12-m",
  "gprop": "web",
  "category": 0,
  "selfCheck": true
}

Custom date range for a region on YouTube:

{
  "keywords": ["iphone", "samsung", "pixel", "xiaomi", "oneplus", "motorola", "nokia"],
  "geo": "US-CA",
  "timeframe": "custom",
  "startDate": "2024-01-01",
  "endDate": "2024-12-31",
  "gprop": "youtube"
}

Field	Description
keywords	1–100 terms (deduplicated case/whitespace-insensitively).
geo	Empty = worldwide, US, US-CA, US-NY-501…
timeframe	now 1-H, now 4-H, now 1-d, now 7-d, today 1-m, today 3-m, today 12-m, today 5-y, all, or custom with startDate/endDate.
gprop	web, news, youtube, images, froogle (Google Shopping).
category	Google Trends category ID, 0 = all.
selfCheck	Validate against a direct query (default true, no extra charge).
includeRelatedQueries, includeInterestByRegion	Optional extra data per keyword.
proxyConfiguration	Residential proxy recommended (default).
maxRequests, maxRuntimeSeconds, maxRetries, requestDelayMs, maxConcurrency, maxRefinementRounds	Safety and speed limits.

Output

Dataset – one row per keyword per date (export as CSV, JSON, Excel…):

{"keyword": "python", "date": "2025-10-12", "timestamp": 1760227200, "value": 57.0,
 "isPartial": false, "status": "ok", "rank": 1, "geo": "US", "timeframe": "today 12-m",
 "gprop": "web", "category": 0}

Key-value store

Record	Content
OUTPUT	Ranking and per-keyword metrics (average, peak, peak date, latest, precision, consistency), validation & self-check, request statistics, warnings.
results_wide.csv	date, keyword1, keyword2, … – ready for Excel / Google Sheets.
summary.csv	One row per keyword with rank and metrics.
results.json	Everything above plus the full time series.
RELATED_QUERIES, INTEREST_BY_REGION	Only when requested.

Keyword status: ok, low_precision (best raw peak < 5 – treat with care), no_data (below Google's detection relative to the other terms – not charged), disconnected/failed (could not be measured – not charged).

Pricing (real numbers)

What you run	Keywords charged	Price
7 programming languages, US, 12 months	7	$0.028
25 brands, one US state, 2024	25	$0.10
100 keywords, worldwide, 5 years	100	$0.40
+ related queries and region breakdown for 6 keywords	12 extras	+$0.024

Plus Apify's standard start fee ($0.00005 per run). No charge per dataset row, no platform-usage add-on.

Pay per event – $4 per 1,000 keywords compared (keyword-compared, charged only for keywords with status ok or low_precision, after the data has been saved). Optional related queries / interest by region: keyword-extra-data, $2 per 1,000. The Actor respects your max cost per run: if the limit allows fewer keywords than you sent, only the first affordable ones are processed and the rest are skipped with a warning.

Use via API

curl -X POST "https://api.apify.com/v2/acts/satin_armeria~google-trends-advanced-comparator/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["python","javascript","rust","golang","kotlin","swift"],"geo":"US","timeframe":"today 12-m"}'

Python:

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("satin_armeria/google-trends-advanced-comparator").call(run_input={
    "keywords": ["python", "javascript", "rust", "golang", "kotlin", "swift"], "geo": "US"})
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")["value"]
rows = client.dataset(run["defaultDatasetId"]).list_items().items

MCP / AI agents: add the Actor to the Apify MCP server (https://mcp.apify.com?tools=satin_armeria/google-trends-advanced-comparator). The input schema is fully described, so an agent only needs keywords (+ optional geo, timeframe).

Limitations (please read)

• Data comes from Google Trends' public web endpoints. Google Trends values are sampled and can change slightly between requests; the consistency metrics and the self-check show you how much.
• Very small keywords relative to the largest one may be no_data or low_precision – this is a property of Google Trends, not a bug. Compare them in a separate run without the giants for more detail.
• Live now … timeframes shift between requests; timestamps not present in every batch are dropped.
• Interest by region is returned per keyword on its own 0–100 scale (not cross-keyword); small regions can dominate for low-volume properties such as News.
• Google may rate-limit (HTTP 429). The Actor backs off and rotates proxy sessions, but very large runs without a proxy can fail; you are never charged for keywords that were not delivered.
• Not affiliated with Google.

FAQ

Why not just use 5-keyword queries? Each query has its own 100. Chaining with a shared anchor and solving all batch scales together is the only way to compare 20–100 terms on one scale.

How accurate is it? On synthetic data with known ground truth (exact Google-style rounding), every well-measured keyword was within 1 index point MAE. In live runs the self-check against a direct Google query had a mean absolute error of 0.15–0.6 points.

Is this an official Google Trends API? No. Google's official Trends API is invite-only (alpha). This Actor reads the same public data the Google Trends website shows.

How is this different from other "compare unlimited keywords" scrapers? We can't verify how other Actors normalize. What we can show: our method is documented above, every run includes a direct-query self-check you can verify yourself, and you are charged only for keywords that were delivered.

What is the cheapest way to try it? Run the prefilled 7-keyword example: it costs about $0.03.