# Google Trends Scraper — Interest, Regions & Rising Queries (`northbell/google-trends-tracker`) Actor

Google Trends for any keywords: interest over time (0-100, average, peak, trend), by region, related and rising queries, and related topics when Google returns them. Compare up to 5 keywords on one scale; set country, period, category, search type. Shows what changed since last run. No login.

- **URL**: https://apify.com/northbell/google-trends-tracker.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 keywords

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Trends Scraper — Interest, Regions & Rising Queries

Give it a list of keywords — and optionally a country, a time range and a category — and get Google Trends as clean rows: **interest over time** (the 0–100 points plus average, latest, peak, change and trend), **interest by region**, **related queries** (top and rising, with the "Breakout" flag) and **related topics** when Google returns them. **$3 per 1,000 keywords** — one keyword with every part you asked for counts once — no login, no API key, no cookies to paste.

Run it again — or put it on a schedule — and every keyword also tells you **what is new since the last run**: how the latest value moved, which **rising queries appeared for the first time**, and how each related query moved up or down the list. Google Trends only shows you the picture of today; this keeps the earlier one for you.

### What you get

Rows have a `type`. Every row has `keyword`, `geo` (`WORLDWIDE` or the code you gave), `timeRange`, `category`, `property` and `observedAt`.

| Row `type` | One row per | Fields |
|---|---|---|
| `timeline` | keyword | `points` (list of `date`, `value` 0–100, `isPartial`), `pointCount`, `resolution` (as Google picks it: `minute`, `eight_minute`, `hour`, `day`, `week`, `month`), `periodStart`, `periodEnd`, `average`, `latest`, `latestDate`, `peak`, `peakDate`, `change` (% from the first quarter of the period to the last), `trend` (`rising` / `falling` / `flat`), `comparedWith` (the other keywords sharing the scale; an empty list unless **compare** is on) |
| `region` | keyword and region | `level` (`country`, `region`, `city` or `metro`), `rank`, `geoName`, `geoCode`, `value` (100 = where the keyword is searched most) |
| `related-query` | keyword and query | `kind` (`top` or `rising`), `rank`, `query`, `value` (0–100 for `top`; growth in % for `rising`), `valueText`, `risingLabel` (`Breakout` or `+250%`), `isBreakout`, `url` |
| `related-topic` | keyword and topic | `kind`, `rank`, `topic`, `topicType`, `topicId`, `value`, `valueText`, `risingLabel`, `isBreakout`, `url` |
| `notice` | keyword and part | `part`, `message` — a part Google had nothing for (free) |
| `error` | keyword and part | `part`, `message` — what failed (free) |

**Since the last run** (`null` on the first run):

| Field | On | What it is |
|---|---|---|
| `previousObservedAt`, `previousLatest`, `previousLatestDate`, `latestChange` | `timeline` | the last complete value from your previous run of the same keyword, place and period, and the difference (positive = interest went up) |
| `newRisingQueries` | `timeline` | rising queries that were not in the previous run's list (needs *Related queries* in **What to read**) |
| `previousRank`, `rankChange`, `isNew` | `related-query`, `related-topic` | position in your previous run (positive `rankChange` = moved up) and `true` when it was not there at all |

### Use it for

- **SEO and content planning** — rising queries around your topic before they peak, and which ones are new this week
- **Seasonality and timing** — when interest builds and fades, per country, for launches, ads and stock
- **Market sizing by place** — which countries, states or metro areas search for a keyword the most
- **Brand and competitor comparison** — up to 5 names on one scale, week after week

### Input

```json
{
  "keywords": ["coffee", "tea", "matcha"],
  "compare": true,
  "geo": "US",
  "timeRange": "past-12-months",
  "include": ["timeline", "regions", "relatedQueries"]
}
```

- **keywords** — one per line, up to 200 per run.
- **compare** — `false` (default): each keyword on its own scale, so its busiest moment is 100. `true`: up to 5 keywords share one scale in one request, so you can see which is bigger.
- **geo** — empty = worldwide; a country (`US`, `JP`) or a region (`US-CA`, `GB-ENG`).
- **timeRange** — `past-hour`, `past-4-hours`, `past-day`, `past-7-days`, `past-30-days`, `past-90-days`, `past-12-months` (default), `past-5-years`, `2004-present`. For exact dates fill **customDateRange** instead, e.g. `2024-01-01 2024-06-30`.
- **category** — Google Trends category ID, `0` = all. **property** — `web` (default), `images`, `news`, `youtube`, `froogle` (Shopping).
- **include** — any of `timeline` (default), `regions`, `relatedQueries`, `relatedTopics`.

What changed since the last run is remembered per keyword, place, period, category and search type in a named key-value store in your Apify account, so the second run of the same input already shows changes. Schedule it (Apify → Schedules) for a daily or weekly log.

#### No keywords yet? Start from what is trending today

`trendingNow` takes a country code (`US`, `GB`, `JP`…). Google Trends' *Trending now* list for that country comes back as `trending` rows — rank, the search, approximate traffic (`approxTraffic` as shown, `approxTrafficMin` as a number), when it started, and the news links behind it — and each search is then analysed like any keyword you typed (its rows carry `trendingIn` and `trendingRank`). The trending list is free; each analysed keyword is charged as usual. With Location empty, that country is used. Run it daily on a schedule for a running log of what took off. *Added 2026-10-24.*

```json
{ "trendingNow": "US", "include": ["timeline", "relatedQueries"] }
```

### Pricing

**$3 per 1,000 keywords** ($0.003 each), plus $0.01 per run. A keyword is charged once, however many parts you ask for. Error rows and notice rows are free, and so is a keyword for which Google has no data. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- **Proxy.** Google Trends answers HTTP 429 (rate limit) to most requests that come straight from cloud servers. The Actor therefore goes through **Apify Proxy (datacenter)** by default, which is part of your Apify plan. Measured on Apify on 8 October 2026: without a proxy 0 of 4 request patterns got data (three runs in a row failed); through Apify Proxy datacenter 3 of 3 and residential 3 of 3. If you turn the proxy off and every keyword fails with 429, turn it back on.
- Values are **relative, 0–100**: 100 is the highest point of the period, place and keyword (or of the whole group when comparing). They are not search counts. Compare runs that use the same period; when the period slides forward, the 100 moves with it.
- The newest point is often **partial** (`isPartial: true`, the day or week is not over). It stays in `points` but is left out of `average`, `latest`, `peak` and `change`. `trend` is `rising` when `change` is +15% or more, `falling` at −15% or less, otherwise `flat`.
- Regions: worldwide gives countries, a country gives its states or regions, and a region such as `US-CA` gives its metro areas. Only regions where Google has data are returned. In compare mode each keyword's regions are scaled on their own.
- **Related topics are usually empty.** In our tests Google returned no topics to automated requests every time, so you get a free `notice` row instead of `related-topic` rows (the `topicType` and `topicId` fields are only there when Google does return topics). They are not offered at all when keywords are compared. Related queries work in both modes.
- `risingLabel` and `isBreakout` are filled on `rising` rows only (`null` on `top` rows). Rising lists are exactly what Google returns: the percentage is growth against the previous period, and `Breakout` means more than +5,000%. For broad keywords the list can include phrases that look unrelated.
- Google rate-limits hard, so the Actor reads about one request every 1.5–2 seconds and, when told to slow down, waits 3, 6, 12 and 24 seconds, each time through a new proxy address with a fresh session. Expect roughly 8–10 seconds per keyword with every part, a few seconds with the timeline only. If Google keeps refusing, the remaining keywords get a free error row and the run says so; run it again later or with fewer keywords. After a long burst Google can keep refusing one connection for an hour or more, so spread very large lists over several runs.
- Related queries that contain an email address or a phone number are left out.
- Public data only: what anyone sees on Google Trends without signing in.

To find keyword ideas first, see [Keyword Suggestions from Autocomplete](https://apify.com/northbell/keyword-suggestions-autocomplete). To track where videos rank for a keyword, see [YouTube Search Rank Tracker](https://apify.com/northbell/youtube-search-rank-tracker).

### For AI agents

`{"keywords": ["coffee"], "timeRange": "past-30-days", "include": ["timeline", "relatedQueries"]}` returns one `timeline` row (points, average, latest, trend) and up to 50 `related-query` rows (`kind` top or rising). Rows have `type`: `timeline`, `region`, `related-query`, `related-topic`, `notice` or `error`. The first four types are billed together as one charge per keyword; `notice` and `error` rows are free.

# Actor input Schema

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

One keyword or phrase per line, as you would type it into Google Trends. Put all your keywords in one run: the run-start fee is charged once. Up to 200 per run.

## `trendingNow` (type: `string`):

A two-letter country code (US, GB, JP, DE…). Today's trending searches there (Google Trends' Trending now: approximate traffic, start time and the news behind each) are added as keywords and analysed like the rest. The trending list itself is free; each analysed keyword is charged as usual. When Location is empty, this country is used.

## `compare` (type: `boolean`):

Off: each keyword is read on its own, so its busiest moment is 100. On: up to 5 keywords go into one Google Trends request and share one 0-100 scale, so you can see which one is bigger. Keywords beyond 5 start a new group. Related topics are not available when comparing.

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

Empty = worldwide. Otherwise a country code (US, GB, DE, JP, IN) or a region code (US-CA, GB-ENG, DE-BY). Regional results then break down by the next level down: countries, then states or regions, then metro areas.

## `timeRange` (type: `string`):

The period to read. Short periods give finer points (minutes to hours), longer ones daily, weekly or monthly points. For exact dates use Custom date range below.

## `customDateRange` (type: `string`):

Two dates, start and end, written like 2024-01-01 2024-06-30. When set, it replaces Time range. Google Trends starts on 2004-01-01 and the end cannot be in the future.

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

Google Trends category ID. 0 = all categories. Examples: 71 Food & Drink, 5 Computers & Electronics, 7 Finance, 45 Health, 18 Shopping. Use it to separate meanings, e.g. 'apple' the fruit from the company.

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

Which Google search the interest is measured in.

## `include` (type: `array`):

The parts to return for every keyword. A keyword is charged once however many parts you pick. Each extra part adds a few seconds, because Google Trends needs a separate request for it.

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

Google Trends answers HTTP 429 (rate limit) to most requests that come straight from cloud servers. Apify Proxy (datacenter, part of your Apify plan) is on by default: in our test on 8 October 2026 every request through it was answered, and none without it. Residential proxies also work but cost more.

## Actor input object example

```json
{
  "keywords": [
    "coffee",
    "tea"
  ],
  "compare": false,
  "geo": "",
  "timeRange": "past-12-months",
  "category": 0,
  "property": "web",
  "include": [
    "timeline",
    "relatedQueries"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `timeline` (type: `string`):

Per keyword: the 0-100 points over time with average, latest, peak, change, trend and what moved since the last run.

## `regions` (type: `string`):

Interest by country, state or metro area for each keyword.

## `relatedQueries` (type: `string`):

Top and rising queries with Breakout flags and what is new since the last run.

## `relatedTopics` (type: `string`):

Top and rising topics (Google often returns none to automated requests).

## `problems` (type: `string`):

Free rows that say why a part is missing.

# 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 = {
    "keywords": [
        "coffee",
        "tea"
    ],
    "include": [
        "timeline",
        "relatedQueries"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/google-trends-tracker").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 = {
    "keywords": [
        "coffee",
        "tea",
    ],
    "include": [
        "timeline",
        "relatedQueries",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "coffee",
    "tea"
  ],
  "include": [
    "timeline",
    "relatedQueries"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call northbell/google-trends-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbell/google-trends-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wjLCJfzpuc8oqmCWg/builds/WXOYWpuGAxB6hpTM9/openapi.json