# Google Trends Scraper - Trending, Interest & Related Queries (`chain_link/google-trends-multi-mode-scraper`) Actor

Scrape Google Trends without a browser: real-time trending searches with traffic volume and news per country, plus interest-over-time, interest-by-region and top/rising related queries for any keyword list. Batch multiple keywords and geos in one run at $0.001 per result.

- **URL**: https://apify.com/chain\_link/google-trends-multi-mode-scraper.md
- **Developed by:** [James White](https://apify.com/chain_link) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 trend record scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 – Trending, Interest & Related Queries

Get Google Trends data as clean rows – no browser, no API key, no setup. This Actor reads Google Trends' own public feeds and data endpoints and turns them into a dataset you can export to Excel, CSV, JSON or push into your own tools.

Four things in one Actor:

1. **Trending** – what people are searching *right now* in a country, with approximate traffic volume, when the topic started trending and the news stories Google links to it.
2. **Interest over time** – the 0–100 popularity curve for any keyword, per week/day/hour depending on the timeframe.
3. **Interest by region** – which states, regions or countries search a keyword the most.
4. **Related queries** – the *top* and *rising* searches people do around your keyword (including “Breakout” risers).

You can pass **several keywords and several countries at once** – every keyword is scraped for every country in a single run.

***

### Price

**$0.001 per result row** (pay per result, on top of Apify platform usage). A 10-country trending run of ~20 topics each costs about $0.20.

***

### Inputs

| Field | Type | Default | What it does |
|---|---|---|---|
| **mode** | string | `trending` | `trending`, `interestOverTime`, `interestByRegion` or `relatedQueries`. Everything except `trending` needs search terms. |
| **searchTerms** | array of strings | `[]` | Keywords to analyse, e.g. `["bitcoin", "ethereum"]`. Needed by every mode except `trending`. |
| **geo** | array of strings | `["US"]` | Country or region codes such as `["US", "GB", "IN"]`. Every keyword is scraped for every code. `[""]` means worldwide, which works in the keyword modes but not in `trending` (Google has no worldwide trending feed). |
| **timeframe** | string | `today 12-m` | `now 1-d`, `now 7-d`, `today 3-m`, `today 12-m`, `today 5-y`, or a date range like `2025-01-01 2025-12-31`. Ignored in `trending` mode. |
| **category** | integer | `0` | Google Trends category ID. `0` = all, `7` = finance, `71` = food & drink. |
| **property** | string | `""` | Search surface: `""` (web search), `images`, `news`, `froogle` (Google Shopping) or `youtube`. |
| **includeNews** | boolean | `true` | In `trending` mode, attach the news headlines, sources and links Google shows for each topic. |
| **hl** | string | `en-US` | Language used for the request, e.g. `en-US`, `de`, `es`. |
| **maxItems** | integer | `500` | Maximum rows for the whole run. `0` means as many as available, up to 20,000. You are never charged for more rows than this. |

#### Example inputs

Trending searches in three countries, with news:

```json
{ "mode": "trending", "geo": ["US", "GB", "IN"], "includeNews": true, "maxItems": 200 }
```

Weekly interest in two keywords over the last year:

```json
{ "mode": "interestOverTime", "searchTerms": ["bitcoin", "ethereum"], "geo": ["US"], "timeframe": "today 12-m" }
```

Rising and top searches around a keyword in two markets:

```json
{ "mode": "relatedQueries", "searchTerms": ["black friday"], "geo": ["US", "GB"], "timeframe": "today 3-m" }
```

***

### Output

One row per data point. Every row has `mode`, `keyword`, `geo`, `sourceUrl` and `scrapedAt`; the other fields depend on the mode.

| Mode | Fields filled |
|---|---|
| `trending` | `rank`, `trafficVolume` (e.g. 200000), `trafficVolumeFormatted` (e.g. "200K+"), `trendStartedAt`, `isActive`, `date`, and `newsArticles` (title, source, url, picture) when `includeNews` is on |
| `interestOverTime` | `date`, `timestamp`, `value` (0–100), `isPartial` (true for the current, unfinished period), `timeframe` |
| `interestByRegion` | `regionName`, `regionCode`, `value` (0–100), `timeframe` |
| `relatedQueries` | `relatedQuery`, `queryType` (`top` or `rising`), `queryValue` (a score for top queries; a growth label such as "+450%" or "Breakout" for rising ones), `rank`, `timeframe` |

`relatedTerms` is included for compatibility but is currently always empty.

Example `interestOverTime` row:

```json
{
  "mode": "interestOverTime",
  "keyword": "bitcoin",
  "geo": "US",
  "timeframe": "today 12-m",
  "date": "2026-03-01T00:00:00+00:00",
  "timestamp": 1772323200,
  "value": 67,
  "isPartial": false,
  "sourceUrl": "https://trends.google.com/trends/api/widgetdata/multiline",
  "scrapedAt": "2026-09-27T07:05:12+00:00"
}
```

Export as JSON, CSV, Excel or XML from the run's Storage tab, or fetch it through the Apify API.

***

### Good to know

- **Values are relative, not search counts.** Google scales every series so its peak is 100. Compare keywords in the same run and region, not across runs.
- **Google limits request rates.** The Actor paces its requests, waits and retries when Google asks it to slow down, and stops cleanly if Google keeps refusing, rather than hammering the service. Very large keyword lists are best split over several runs.
- **Low-volume keywords** may return no related queries or regional data. Google only publishes these when there is enough search volume.
- **What it does not do:** no logins, no browser, and no personal data. Everything returned is aggregate trend statistics and public news headlines.

### Is this allowed?

The Actor reads public, unauthenticated Google Trends pages and data endpoints and collects aggregate statistics only. Google's Terms of Service discourage automated access, so review them for your use case, keep runs modest, and use the data responsibly.

### Support

Found a problem or need a field added? Open an issue on the Actor's **Issues** tab and include the run ID.

# Actor input Schema

## `mode` (type: `string`):

What to extract: 'trending' (real-time trending searches per country), 'interestOverTime', 'interestByRegion', or 'relatedQueries'. All modes except 'trending' require searchTerms.

## `searchTerms` (type: `array`):

Keywords to analyse, e.g. \["bitcoin","ethereum"]. Used by interestOverTime, interestByRegion and relatedQueries modes.

## `geo` (type: `array`):

ISO country (or region) codes such as \["US","GB","IN"]. Every keyword is scraped for every geo. \[""] means worldwide in the keyword modes; trending mode needs a country code.

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

Google Trends timeframe string, e.g. 'now 1-d', 'now 7-d', 'today 3-m', 'today 12-m', 'today 5-y', or '2023-01-01 2023-12-31'. Ignored in trending mode.

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

Google Trends category ID (0 = all categories, 7 = finance, 71 = food & drink, ...).

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

Search surface: '' (web search), 'images', 'news', 'froogle' (shopping) or 'youtube'.

## `includeNews` (type: `boolean`):

In trending mode, include the news headlines, sources and links Google attaches to each trending topic.

## `hl` (type: `string`):

Interface language code used for the request, e.g. 'en-US', 'de', 'es'.

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

Maximum number of result rows across all keywords and geos. 0 means as many as available, up to 20,000.

## Actor input object example

```json
{
  "mode": "trending",
  "searchTerms": [],
  "geo": [
    "US"
  ],
  "timeframe": "today 12-m",
  "includeNews": true,
  "hl": "en-US",
  "maxItems": 500
}
```

# Actor output Schema

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

No description

# 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 = {
    "mode": "trending",
    "searchTerms": [],
    "geo": [
        "US"
    ],
    "timeframe": "today 12-m",
    "category": 0,
    "property": "",
    "includeNews": true,
    "hl": "en-US",
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("chain_link/google-trends-multi-mode-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 = {
    "mode": "trending",
    "searchTerms": [],
    "geo": ["US"],
    "timeframe": "today 12-m",
    "category": 0,
    "property": "",
    "includeNews": True,
    "hl": "en-US",
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("chain_link/google-trends-multi-mode-scraper").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 '{
  "mode": "trending",
  "searchTerms": [],
  "geo": [
    "US"
  ],
  "timeframe": "today 12-m",
  "category": 0,
  "property": "",
  "includeNews": true,
  "hl": "en-US",
  "maxItems": 500
}' |
apify call chain_link/google-trends-multi-mode-scraper --silent --output-dataset

```

## MCP server setup

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

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/jHL8Sm0Hg0x46LKFo/builds/T3F904GCbZIWgaXUU/openapi.json