# Google Trends Scraper: Queries, Regions & Trending Now (`glitchbound/google-trends-scraper`) Actor

Scrape Google Trends: interest over time, interest by region, related and rising queries, and real-time Trending Now searches. Batch up to 100 keywords, any country, any timeframe. Charged per row of real data, so a keyword that returns nothing costs nothing.

- **URL**: https://apify.com/glitchbound/google-trends-scraper.md
- **Developed by:** [Daniel Meshulam](https://apify.com/glitchbound) (community)
- **Categories:** SEO tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Trends Scraper: Queries, Regions & Trending Now

Extract **Google Trends data at scale**: search interest over time, interest by country and region, related queries (top + rising), and real-time **Trending Now** searches, up to 100 keywords per run, any country, any timeframe.

### If it returns nothing, you pay nothing

The usual way a Google Trends scraper wastes your money is that it runs for twenty minutes, hits Google's rate limits, and hands you an empty dataset, after billing you the whole time.

This one is built so that can't happen:

- **You are charged per row of real data.** Billing on dataset writes is switched off entirely, so a failed keyword produces an `error` row that costs **$0.00**. No data, no charge.
- **Memory is capped at 512 MB** (most Actors default to 4 GB). Compute is billed as memory × time, so a slow run here costs a fraction of what the same run costs elsewhere.
- **No headless browser.** Plain HTTP against Google's own endpoints, runs finish in about a minute, not twenty.
- **One bad keyword never kills the run.** Each keyword is isolated; the other 99 still return.
- **Your run charge limit is honored.** Set a maximum charge and the Actor stops cleanly at it instead of burning compute for revenue it can't collect.

Rotating proxies and staged backoff handle Google's rate limiting, which is what causes most empty results in the first place.

### When to run it (measured, 2026-07-29)

Google gates `trends.google.com/trends/api/*` behind a session cookie, and it
gates it harder during US and European working hours. This is not a claim about
this Actor, it is what the endpoint does to everyone, which is why
`pytrends 429`, `pytrends 404` and `gtrendsR: status code was not 200` are
perennial Stack Overflow questions.

What was measured, on the same keyword, the same day:

| | |
|---|---|
| 03:17 UTC | full results in 41 seconds |
| 12:22-13:37 UTC | `429` on every attempt |
| Waiting 30s, 60s, 120s between tries | still `429` |
| Datacenter proxy, residential proxy, and no proxy at all | **identical**: all blocked |
| The same request from an ordinary home connection, same minute | **200** |

Two things follow, and they are worth knowing before you build on any Google
Trends tool:

- **Backoff does not buy you through it.** Two full minutes of waiting changed
  nothing. An Actor that "retries harder" is just billing you for the wait.
- **Switching proxy tier does not help.** Datacenter, residential and Apify's
  own egress all fail identically, while an ordinary home connection succeeds in
  the same minute. Google is judging the address, and every address a cloud
  platform can offer for this endpoint is already spent - the residential pool
  included, because it is shared by thousands of scrapers. Paying for
  residential bandwidth here buys nothing.

#### If you need it during the day: bring your own proxy

The `Proxy` input accepts **Custom proxy URLs**. That is the one setting here
that changes the outcome, because the block is on the address and every address
a cloud platform can offer is already spent. A proxy on IPs that are not shared
with thousands of other scrapers gets the same 200 an ordinary home connection
gets.

```json
{
  "keywords": ["matcha"],
  "proxyConfiguration": { "useApifyProxy": false, "proxyUrls": ["http://user:pass@your-proxy:8000"] }
}
```

Nothing else in the input moves the needle. Turning Apify Proxy on or off, or
switching it between datacenter and residential, was measured to make no
difference at all.

**The practical answer is to schedule it outside those hours.** Apify Schedules
can run this nightly; roughly 00:00-06:00 UTC has been reliable. For ad-hoc
research during the day, expect `error` rows, which, as below, cost you
nothing.

### Do you need an API key? No. Is there a free tier? Yes.

The two things people search for in this category, measured, are **free** and
**API key**: `google trends api free`, `google trends api key`.

So, plainly:

- **No API key.** Nothing to register for, nothing to rotate, no key to leak in
  a repo. The source is a public API published deliberately by its owner.
- **No proxy setup.** The source does not bot-wall datacenter addresses, so the
  default works.
- **Pay per result, not per month.** There is no subscription and no minimum.
  Rows that error or that your filters drop are **not charged**.
- **Free to try.** Run it with the prefilled input and see real rows before
  deciding anything.

### What you get

| Data type | What it returns |
|---|---|
| **Keyword comparison** | Up to 5 keywords on **one shared 0-100 scale**, with each one's average, peak, and rank |
| **Interest over time** | 0-100 search-interest score per week/day/hour for your timeframe |
| **Interest by region** | Score per country, state, or US metro area |
| **Related queries** | Top related searches + **rising** searches (with growth %, including "Breakout") |
| **Trending Now** | Real-time trending searches for any country, with approximate traffic and linked news |

### What this Actor deliberately does not return

Two Google Trends data types are widely advertised by scrapers and **do not actually work**, because Google itself stopped returning them:

| Not included | Why |
|---|---|
| **Related topics** | Google's endpoint returns an empty ranked list on both of its backends. Every result would be blank. |
| **City-level interest** | Google returns 200 cities with `hasData: false` on every one. Region (51) and US metro (210) do return real data, and both are supported. |

Shipping an option that silently returns nothing is the fastest way to waste your money, so these were removed rather than left in the input schema to look impressive. Everything the schema offers returns data.

### Use cases

- **SEO & content research**: find rising queries before they peak; catch "Breakout" terms early
- **E-commerce & dropshipping**: validate product demand by country before you spend on ads
- **Market research**: compare seasonality and regional demand across markets
- **Trading & finance signals**: track search interest for tickers, brands, and events
- **AI agents & LLM pipelines**: clean JSON via API, ready for automated workflows
- **News & social monitoring**: Trending Now with attached news stories, refreshed in real time

### Compare keywords head-to-head

Set `compareKeywords: true` and every keyword is scored against the **same** ceiling, so the numbers are directly comparable, the question Google Trends is most often asked:

```json
{ "keywords": ["nike", "adidas", "new balance", "hoka"], "compareKeywords": true, "geo": "US" }
```

```
#1  nike           avg 53.6   peak 100
#2  adidas         avg 23.0   peak  52
#3  new balance    avg 16.3   peak  34
#4  hoka           avg  6.6   peak  14
```

Each row carries the full timeline plus `averageInterest`, `peakInterest`, and `rank`, so you can chart it or sort it without post-processing.

### Input example

```json
{
  "keywords": ["matcha", "protein powder", "creatine gummies"],
  "dataTypes": ["interestOverTime", "relatedQueries", "interestByRegion"],
  "geo": "US",
  "timeframe": "today 12-m",
  "trendingNowGeo": "US"
}
```

### Output example (one row per keyword × data type)

```json
{
  "keyword": "matcha",
  "dataType": "relatedQueries",
  "geo": "US",
  "timeframe": "today 12-m",
  "top": [{ "query": "matcha latte", "value": 100 }],
  "rising": [{ "query": "matcha shortage", "formattedValue": "Breakout" }]
}
```

Export as JSON, CSV, Excel, or feed it straight into Google Sheets, Make, Zapier, LangChain, or your own code via the [Apify API](https://docs.apify.com/api/v2).

### Pricing

Pay per result: you are charged a small fee per successfully returned data row (keyword × data type). Failed lookups cost nothing. A run with 10 keywords × 2 data types = 20 results.

### There is no official Google Trends API

Google has never shipped one. There is no key to request, no quota page, and no
endpoint in the Cloud console. What exists is the set of internal endpoints the
trends.google.com page calls to render itself, and every tool in this space
including this one is a typed wrapper over those.

That is worth knowing before you pick anything here, because it sets what is
actually true of all of them:

- **No API key exists to obtain.** Any product offering you a "Google Trends API
  key" is issuing its own key for its own proxy.
- **Values are relative, 0 to 100, never absolute search volume.** Google does
  not publish volume through this surface at all.
- **The endpoints rate-limit hard by IP**, which is the single thing that
  decides whether a run works. See the proxy note below; it is not optional for
  keyword analysis.

**Timeframes**: `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`,
`today 3-m`, `today 12-m`, `today 5-y`, and `all` for 2004 to present.

**Data types**: interest over time, interest by region (country, region or DMA
resolution), related queries, rising queries, and **Trending Now**, which is the
real-time surface and is the one path that needs no proxy of your own.

**Any country**, via `geo`, plus category and property filters (web, images,
news, YouTube, Shopping).

### Trending Now across markets

Pass several countries and each one runs in the same job:

```json
{ "trendingNowGeo": "US, GB, DE, IL" }
```

Every row carries its own `geo` and its `rank` **within that country**, so a
row ranked 1 in Israel and a row ranked 1 in Germany are both firsts rather than
being renumbered into one list. That is the comparison people actually want, and
it used to take one run per market.

`approxTrafficMin` is the numeric form of Google's `approxTraffic`, which it
publishes as `500+`, `20K+` or `2M+`. Those sort alphabetically and cannot be
filtered, so the number is there for "anything above 50,000".

Each trend also carries the news stories Google attached to it, with title,
source, URL, snippet and image, which is usually enough to see **why** something
is trending without following the link.

**This path needs no proxy of your own.** It reads Google's trending RSS feed,
which is not rate-limited on Apify, unlike the keyword endpoints below.

### Notes & fair use

- Google Trends values are **relative** (0-100 within your query), not absolute search volumes.
- By default each keyword is normalized independently. Set `compareKeywords: true` to put up to 5 on one shared 0-100 scale (see above).
- Regions with no search data are omitted rather than returned as zeros, so every row you get is a real signal.
- This Actor collects **publicly available, aggregated, anonymous** data only, no personal data is touched.

### FAQ

**Why do I sometimes see a keyword with an `error` field?**
Google aggressively rate-limits. The Actor retries with rotating proxies and exponential backoff; in the rare case a keyword still fails, it's reported transparently and not charged.

**Does it support any country?**
Yes. Worldwide by default, or any ISO country/region code (`US`, `GB`, `DE`, `IL`, `US-CA`).

**Can I schedule it?**
Yes. Use Apify Schedules to run it hourly or daily and deliver fresh trend data to your stack automatically.

# Actor input Schema

## `keywords` (type: `array`):

Search terms to analyze, one per line. Each keyword is fetched independently (its scores are normalized 0-100 against itself). Up to 100 per run. Keyword analysis needs your own proxy, because Google rate-limits every shared datacenter and residential address Apify can reach for this endpoint. Trending Now below needs no proxy.

## `compareKeywords` (type: `boolean`):

Score all your keywords on ONE shared 0-100 scale, so they can be compared directly (e.g. is Nike or Adidas trending harder?). Uses the first 5 keywords, and returns each one's average, peak, and rank. Leave off to analyze each keyword independently.

## `dataTypes` (type: `array`):

Which datasets to fetch for every keyword. Ignored when 'Compare keywords' is on.

## `geo` (type: `string`):

Two-letter country code (US, GB, DE, IL…), or a region like US-NY. Leave empty for worldwide.

## `timeframe` (type: `string`):

Google Trends timeframe.

## `regionResolution` (type: `string`):

Granularity for interest-by-region.

## `category` (type: `integer`):

Google Trends category ID to narrow results (0 = all categories). Example: 71 = Food & Drink.

## `property` (type: `string`):

Which Google surface to measure.

## `trendingNowGeo` (type: `string`):

Real-time trending searches for these countries, e.g. US or US, GB, DE, IL. Served from Google's trending RSS feed, which is not rate-limited on Apify, so it works with no proxy of your own. Several countries run in one job and each row carries its own country and its rank within that country. Works with or without keywords.

## `proxyConfiguration` (type: `object`):

Proxy settings. Measured 2026-07-29: Apify Proxy does not get past Google's block on this endpoint - datacenter, residential and no-proxy all return 429 while an ordinary home connection succeeds in the same minute. If you have your own clean proxy, put it in Custom proxy URLs; that is the one setting here that changes the outcome.

## `maxItems` (type: `integer`):

A hard ceiling on rows for the entire run, across every target. The per-target limits above cap each one separately, so fifty targets at twenty each is still a thousand rows; this caps the total. The run stops cleanly when it is reached and nothing beyond that point is fetched or charged. Leave empty for no ceiling.

## Actor input object example

```json
{
  "compareKeywords": false,
  "dataTypes": [
    "interestOverTime",
    "relatedQueries"
  ],
  "timeframe": "today 12-m",
  "regionResolution": "COUNTRY",
  "category": 0,
  "property": "",
  "trendingNowGeo": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Interest over time, regional breakdowns, related queries and trending searches.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "geo": "",
    "trendingNowGeo": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("glitchbound/google-trends-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "geo": "",
    "trendingNowGeo": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("glitchbound/google-trends-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "geo": "",
  "trendingNowGeo": "US"
}' |
apify call glitchbound/google-trends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=glitchbound/google-trends-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/5AE1nraH8B1jYh2TT/builds/s2lgHP82UvsmRYPfV/openapi.json