How to Scrape Google Trends in 2026 (API & Python)

The fastest way to get Google Trends data in 2026 is to call a structured Trends API that returns normalized JSON — interest-over-time series, rising and top related queries, interest by region, and trending searches — instead of automating the Trends site yourself. Google's own Trends API exists only in a limited, application-gated alpha (launched July 2025) and is not generally available in 2026, so for most developers the practical choice is a maintained endpoint that handles the request shape and parsing for you.

One thing to know up front: Google Trends values are relative and normalized to 0–100, not absolute search counts. That is true however you collect them, so build your analysis around relative movement, not raw volume.

Is there an official Google Trends API in 2026?

Short answer: yes, but you almost certainly can't use it yet. Google launched an official Google Trends API in alpha in July 2025, but a year on it is still application-gated, allowlisted, and not generally available — access is granted to a small pool of testers on a rolling basis, so most developers still have no way in. Meanwhile the long-standing pytrends wrapper was archived (read-only) in April 2025, so it is unmaintained and its rate-limit (HTTP 429) failures go unpatched. Until the official API opens up, the reliable route in 2026 is a maintained third-party endpoint — like Crawlora's Google Trends API — that returns the same interest-over-time, rising and top queries, and trending data as normalized JSON with no waitlist.

Is it legal to scrape Google Trends?

Google Trends is public data, and collecting public data is generally treated differently from accessing private accounts — but it is not unconditional:

• Collect only the public Trends surfaces; no login-gated data.
• Respect rate limits and avoid hammering the service.
• Review Google's terms and your local law before commercial redistribution.
• Remember the values are normalized indices, so represent them honestly in any product.

This is not legal advice — see Is web scraping legal in 2026? for the detail.

Option 1: DIY in Python (and why it breaks)

The common DIY route is an unofficial library such as pytrends that mimics the Trends frontend:

from pytrends.request import TrendReq

pytrends = TrendReq()
pytrends.build_payload(["ai agents"], timeframe="today 12-m", geo="US")
df = pytrends.interest_over_time()

It works until it doesn't. The recurring pain:

• Rate limiting and 429s — Google throttles the internal endpoints aggressively, so you need proxies and backoff.
• Unofficial and unstable — these libraries track an undocumented internal API that changes without notice.
• Payload quirks — timeframes, geos, and category codes are fiddly and easy to get subtly wrong.
• Normalization across requests — comparing keywords pulled in separate calls is unreliable because each batch is renormalized.

Option 2: No-code and ready-made tools

Dashboards and browser tools can show you a chart, but they rarely give you the underlying series in a form you can store, join, or schedule. For anything that feeds a pipeline or a product, you want the JSON.

Option 3: A structured Google Trends API

Crawlora's Google Trends API exposes documented endpoints for interest over time, rising and top queries, related topics, interest by region, and trending searches — all returning normalized JSON.

curl -X POST "https://api.crawlora.net/api/v1/google/trends/explore/interest-over-time" \
  -H "x-api-key: $CRAWLORA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["ai agents"], "geo": "US", "timeframe": "today 12-m"}'

import requests

resp = requests.post(
    "https://api.crawlora.net/api/v1/google/trends/explore/interest-over-time",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={"keywords": ["ai agents"], "geo": "US", "timeframe": "today 12-m"},
)
for point in resp.json()["data"]["timeline"]:
    print(point["date"], point["values"])

A response is normalized JSON (fields are illustrative — confirm the exact request body and schema in the docs):

{
  "code": 200,
  "msg": "OK",
  "data": {
    "timeline": [
      { "date": "2026-05-01", "values": [{ "keyword": "ai agents", "value": 72 }] }
    ]
  }
}

For discovery rather than tracking, surface what is gaining momentum with the rising/top-queries and trending endpoints:

h = {"x-api-key": "YOUR_API_KEY"}
base = "https://api.crawlora.net/api/v1/google/trends"

rising = requests.post(f"{base}/explore/rising-queries", headers=h,
                       json={"keywords": ["ai agents"], "geo": "US"}).json()["data"]
trending = requests.get(f"{base}/trending", headers=h, params={"geo": "US"}).json()["data"]

Pass up to 5 keywords in one interest-over-time call so they're normalized together — the comparison that breaks when you batch them in separate requests.

What you can collect

• Interest over time as a normalized 0–100 series per keyword
• Rising and top related queries for a term
• Related topics and interest by region
• Trending searches and trending detail for what is spiking now

Limitations and common challenges

• Official API is alpha-only. Google launched an official Trends API in July 2025, but it stays in application-gated alpha (not generally available in 2026); the unofficial pytrends library was archived in April 2025 and hits an internal endpoint that rate-limits (429) and changes without notice.
• Values are relative, not absolute. Every series is normalized 0–100 within its request — these are indices, not search counts; represent them honestly and don't read them as volume.
• Normalize in one call. Pass up to 5 keywords together so they share one scale; batching them in separate requests renormalizes each and makes them incomparable.
• Geo, timeframe, and category quirks. Location codes, timeframes, and category ids are fiddly; use the enums and locations endpoints to get them right.

Sources

Where this fits

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Trends data is most powerful next to search rankings. Pair demand with visibility: when a query is rising, check whether you rank for it using the Google Search API or the cross-engine SERP monitoring workflow, and prioritize content where demand is climbing. For SEO and content planning, that demand-plus-rankings loop is the whole point — see the best SERP APIs in 2026 for the ranking side, how to scrape Brave Search for an alternative engine, how to scrape Google Maps to match regional demand against the businesses on the ground, and how to choose a web scraping API for the broader toolkit. Demand curves also read well against other evidence of the same interest: how to scrape Yahoo Finance when the rising query is a ticker or a company, how to scrape Google Scholar when it's a research topic and you want the literature behind the spike, and how to scrape JustWatch when it's a film or series and you want to know which services actually carry it.

Get started by testing the endpoint in the Playground, reading the request and response schema in the API docs, and reviewing credit costs on the pricing page.