Google Trends API

SEO & keywords · v1.1.0 · google_trends

$0.0005 / trend

$0.40 / 1K · pay per delivered trend

A Google Trends API that returns today's trending searches for a country as rows, not a page. Send a country code and get back each rising query with Google's traffic band, when it surfaced, a representative image and the news stories Google attached to it — billed per trend delivered.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0005 per delivered trend · $2 free every month · Failed runs never billed

What it does

What a Google Trends API does

This reads the trending-searches feed — the surface that lists what a country is searching right now, ranked, each with an approximate traffic band (Google never publishes an exact number) and the articles that explain why the query is climbing. It is the daily-trending view, not the interest-over-time curve for a keyword you already have in mind.

Google's own Trends API is in limited, access-gated alpha and centres on scaled interest over time; this collector needs no waitlist and answers from a plain request with no browser in the path. The feed is region-locked and lightly defended, so what it saves you is the exit rotation and the parsing — you send a country, you get rows.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`country`	string	no	ISO 3166-1 alpha-2 code — which country's trending feed to read (default us).
`max_results`	integer	no	How many trends to deliver at most (1–20). You pay only for delivered trends.

Outputs — 10 fields, one row per trend

What one trend looks like

Every delivered trend carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	Position in today's feed.
`query`	string	The trending search query.
`approx_traffic`	string · nullable	Google's traffic band, e.g. "1000+".
`published`	string · nullable	When Google surfaced the trend.
`image`	string · nullable	Representative image URL.
`articles`	object[]	News stories attached to the trend ({ title, url, source }).
`country`	string	Country the feed was read for.
`traffic_min`	integer · nullable	approx_traffic as a number ("2000+" → 2000).
`published_at`	string · nullable	published as an ISO 8601 timestamp.
`article_count`	integer	How many stories are attached.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/google_trends/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/google_trends/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"country":"us","max_results":10}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/google_trends/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "country": "us",
        "max_results": 10
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/google_trends/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"country":"us","max_results":10}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the google_trends collector with country="us" and max_results=10

Example response

POST /v1/scraper/collectors/google_trends/run

$ curl $QD/google_trends/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"country": "us", "max_results": 10}'
{ "status": "done", "count": 10,
  "results": [
    {
      "query": "…",
      "approx_traffic": "…",
      "published": "…",
      "image": "…" } ],
  "cost": 0.005 }
# 10 trends × $0.0005 · nothing delivered, nothing charged

Try it

Google Trends — trending now, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Google Trends API: from country, QuanticData reads the Trends page and returns one row per trend with approx_traffic, published and traffic_min, at $0.0005 per delivered trend. — You send country and max_results; the run goes out through a residential exit and comes back as trends with rank, query and approx_traffic — 10 fields on every row — and you are billed $0.0005 for each trend actually delivered, nothing for a run that delivers none.

$0.0005 / trend4,000 trends on the free $2 every month

Semantic inputcountry, max_results — no URL lists

Up to 20trends per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

Google Trends API pricing

$0.0005 per delivered trend. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 4,000 trends before you spend anything.

$0.0005per delivered trend$0.4 per 1,000 delivered trends

4,000 trendson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the Google Trends API

Three shapes of work this endpoint was designed around.

Newsroom monitoring

Poll a country's feed on a schedule and flag when a query enters the top ranks, with the attached articles already there to source the story.

Trend-jacking content

Pull the rising queries for your market each morning and brief copy against the ones that sit next to your product.

Demand signals

Store the daily feed per country to build your own history of what broke out and when, using the traffic band as a rough magnitude.

Google Trends API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Access	Official Trends API in gated alpha, waitlisted	A country code, answered now
Shape	A page, or a library that breaks on the next markup change	Parsed rows: query, traffic band, published, articles
Attached news	Gathered in a second pass	The stories Google linked, on every trend

What people search for

Live autocomplete demand around Google Trends — trending now, pulled with our own Keyword ideas collector.

Google Trends API: the POST to the google_trends collector, 10 trends delivered and the bill, 10 × $0.0005 = $0.005 in usage.cost_usd; zero trends would cost $0. — The same call you would paste into a terminal: a Bearer key, country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many trends arrived and usage.cost_usd is $0.005, which is 10 × $0.0005. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Google Trends API.

Something else? Ask us

Is this the official Google Trends API?

No. Google's official Trends API is in limited alpha and access-gated; this is an independent collector that reads the public trending-searches feed for a country and returns it as rows, with no waitlist to join.

Do I get interest over time for a keyword?

No — this is the trending surface, not the interest-over-time curve. It answers what a country is searching right now, ranked, with a traffic band and attached news, rather than a twelve-month line for a keyword you name.

Which countries can I read?

Any country Google publishes a trending feed for: pass the ISO country code and the feed comes back for that region. One call reads one country's feed.

How precise is the traffic figure?

Google publishes a band, not a number ("1000+"), so the collector returns exactly that band and never invents a precise count. Treat it as a rough magnitude, not a measured volume.

Is there a free Google Trends API?

Every account gets $2 of credit every month with no card, which is about 4,000 delivered trends on this endpoint at $0.0005 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0005. A run capped at 20 trends — the maximum for this collector — costs $0.01 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Google Trends API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (Trends page) turn into clean JSON with the fields approx_traffic, published and traffic_min; 10 fields on every row.