# Google Trends Scraper - Interest, Regions, Related & Trending (`clearfetch/google-trends-scraper`) Actor

Google Trends without a browser: interest over time, interest by region and related queries for keywords and comparisons ("chatgpt vs gemini"), plus today's trending searches by country. Paces itself so runs finish instead of failing. No login.

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

## Pricing

from $2.10 / 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, Related & Trending

Get Google Trends data for any list of keywords without a browser: interest over time, interest by country or
state, and top and rising related queries, for single keywords or comparisons of up to five terms
("chatgpt vs gemini"). It also returns what is trending in Google Search right now in any country. **$3 per 1,000
keywords, $0.50 per 1,000 trending searches.** No login, no proxy.

### What data you get

**One row per keyword or comparison:**

- `interestOverTime`: every point in the range with `date`, `label`, `value` (0-100) and `values` per compared term,
  `isPartial` for the period still running
- `averages` per term, and for the first term: `peakValue`, `peakDate`, `latestValue`, `changePercent` (last quarter
  of the range against the first)
- `interestByRegion`: countries worldwide, or states and regions within a country, highest first, with values per term
- `relatedQueries`: top queries (scored 0-100) and rising queries (growth in percent, or "Breakout"), per term,
  each with a link to its own Trends page
- `keyword`, `terms`, `geo`, `timeRange`, `category`, `property`, and `url`, the same query on trends.google.com

**One row per trending search** (with **Trending now: countries**): `title`, `rank`, `approxTraffic` ("2000+") and
`approxTrafficMin` (2000), `publishedAt`, picture and linked `news` articles when Google has them.

### How to use

1. Add keywords, one per line. Put up to five terms on one line with `vs` to compare them.
2. Pick the country (or leave it empty for worldwide) and the time range; optionally a category or YouTube, News,
   Images or Shopping search. Add country codes under **Trending now** for today's trending searches.
3. Run it, then download JSON, CSV or Excel, or pull the rows through the API.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` | array | — | One keyword per line; `a vs b vs c` compares up to 5. Also `searchTerms`, `keyword`. |
| `geo` | string | worldwide | Country (`US`) or region (`US-CA`) code. |
| `timeRange` | string | `today 12-m` | `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m`, `today 5-y`, `all`. |
| `customTimeRange` | string | — | `2025-01-01 2025-06-30`; overrides `timeRange`. |
| `category` | integer | `0` | Google Trends category id (0 = all). |
| `property` | string | web | `images`, `news`, `froogle` (Shopping) or `youtube`. |
| `includeRegions` | boolean | `true` | Interest by region. |
| `includeRelatedQueries` | boolean | `true` | Top and rising related queries. |
| `trendingNowGeos` | array | `[]` | Country codes for today's trending searches. |
| `language` | string | `en-US` | Language for query and region names. |
| `maxItems` | integer | `0` | Stop after this many charged rows (0 = no limit). |
| `minDelaySecs` | integer | `2` | Minimum wait between requests; the Actor slows down further on its own when Google pushes back. |
| `timeoutSecs` | integer | `30` | Per request. |
| `proxyConfiguration` | object | off | Not needed; your own proxies can speed up very large runs. |

### Output example

Real rows from a run on 2026-09-29 (arrays shortened here to their first items):

```json
{
    "ok": true,
    "type": "keyword",
    "keyword": "coffee",
    "terms": ["coffee"],
    "geo": "US",
    "timeRange": "today 3-m",
    "category": 0,
    "property": "web",
    "url": "https://trends.google.com/trends/explore?q=coffee&date=today+3-m&geo=US&hl=en-US",
    "interestOverTime": [
        { "date": "2026-06-29T00:00:00.000Z", "label": "Jun 29, 2026", "value": 53, "values": { "coffee": 53 }, "isPartial": false },
        { "date": "2026-06-30T00:00:00.000Z", "label": "Jun 30, 2026", "value": 50, "values": { "coffee": 50 }, "isPartial": false }
    ],
    "averages": { "coffee": 56 },
    "peakDate": "2026-07-19T00:00:00.000Z",
    "peakValue": 100,
    "latestValue": 49,
    "changePercent": -9.7,
    "interestByRegion": [
        { "geoCode": "US-KS", "geoName": "Kansas", "value": 100, "values": { "coffee": 100 } },
        { "geoCode": "US-HI", "geoName": "Hawaii", "value": 99, "values": { "coffee": 99 } }
    ],
    "relatedQueries": [
        { "term": "coffee", "kind": "top", "query": "coffee near me", "value": 100, "formattedValue": "100", "link": "https://trends.google.com/trends/explore?q=coffee+near+me&date=today+3-m&geo=US" },
        { "term": "coffee", "kind": "rising", "query": "top songs this week", "value": 21750, "formattedValue": "Breakout", "link": "https://trends.google.com/trends/explore?q=top+songs+this+week&date=today+3-m&geo=US" }
    ],
    "missingSections": [],
    "scrapedAt": "2026-09-29T12:38:22.632Z",
    "partial": false
}
```

```json
{
    "ok": true,
    "type": "trending",
    "geo": "US",
    "title": "taylor sheridan",
    "approxTraffic": "2000+",
    "approxTrafficMin": 2000,
    "publishedAt": "2026-09-29T12:20:00.000Z",
    "picture": null,
    "pictureSource": null,
    "news": [],
    "rank": 1,
    "scrapedAt": "2026-09-29T12:38:11.470Z"
}
```

A line that cannot be answered comes back as one row with `ok: false` and a plain reason, such as `Google Trends has
too little search data for this query in this region and time range`. Those rows are free.

### Pricing

- **$0.003 per keyword or comparison**, which is $3 per 1,000, with every section you asked for.
- **$0.0005 per trending search**, $0.50 per 1,000 (a country's feed is usually 10-20 of them).
- Lines that fail, keywords without enough search data, and rows where Google withheld a section after all retries
  (`partial: true`) are never charged.

Paid Apify plans pay less: 10% off on Bronze, 20% on Silver and 30% on Gold and higher tiers.

### Use cases

- **SEO and content planning**: which topics are rising, which related queries are breaking out, where interest is
  strongest.
- **Product and market research**: compare brands, products or categories over five years, by country or state.
- **E-commerce and seasonality**: when demand for a product peaks, in Shopping search specifically.
- **Newsrooms and social teams**: today's trending searches by country on a schedule.
- **Data science**: clean time series for models and dashboards, one run for hundreds of keywords.

### FAQ

**Why does a large run take a while?** Google Trends limits how often one IP may ask, and answers too-fast requests
with HTTP 429. Instead of failing those keywords, the Actor paces itself: it starts at one request every two seconds,
waits and slows down when Google pushes back, and speeds up again when it can. Each keyword takes four or more
requests. A run that finishes a little later with complete data beats one that returns errors.

**Are the numbers search volumes?** No. Google Trends reports relative interest from 0 to 100, where 100 is the
peak within the query's own range and region. In a comparison, all terms share one scale, so they can be compared
directly.

**Does it need a proxy?** No. Your own proxies can speed up very large runs, since Google's limit is per IP.

**Why is a row marked partial?** Google occasionally keeps refusing one section even after several retries. The
row is written with what did arrive, lists the missing section in `missingSections`, and is not charged.

**Is it legal?** It reads the same public, aggregated and anonymous data that anyone sees on trends.google.com. You
are responsible for how you use it.

### Integrations

Run it from the Apify API or a client library, schedule it in Apify Console, or connect it to n8n, Make, Zapier or
any MCP client through Apify's integrations. Results are available as JSON, CSV, Excel and through the dataset API.

### More tools from clearfetch

- [TikTok Scraper](https://apify.com/clearfetch/tiktok-scraper): hashtags, profiles, sounds and video stats in one Actor
- [Website Sitemap Extractor](https://apify.com/clearfetch/website-sitemap-extractor): every URL of a website from its sitemaps, from just the domain
- [ATS Jobs Scraper](https://apify.com/clearfetch/ats-jobs-scraper): every open job from company careers pages on Greenhouse, Lever, Ashby, Workday and more

### Changelog

- **1.0.0** (2026-09) — first release: interest over time, by region and related queries for keywords and
  comparisons of up to five terms, trending searches by country, self-pacing against Google's rate limit.

# Actor input Schema

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

One per line. Compare up to 5 terms on one line with "vs": chatgpt vs gemini vs claude. Each line returns interest over time, interest by region and related queries. Also accepts "searchTerms" and "keyword".

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

Two-letter country code (US, GB, DE) or region code (US-CA). Empty for worldwide.

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

Past hour to 2004-present. Shorter ranges give hourly or daily points, longer ones weekly or monthly.

## `customTimeRange` (type: `string`):

Overrides the time range: "2025-01-01 2025-06-30".

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

Google Trends category id, e.g. 71 Food & Drink, 5 Computers & Electronics. 0 is all categories.

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

Which Google search the interest is measured on.

## `includeRegions` (type: `boolean`):

Countries worldwide, or states and regions within a country.

## `includeRelatedQueries` (type: `boolean`):

Top and rising related searches for each term.

## `trendingNowGeos` (type: `array`):

Country codes (US, GB, IN...). Returns what is trending in Google Search there right now, with approximate traffic and linked news. Works with or without keywords.

## `language` (type: `string`):

Language for query and region names, e.g. en-US, de, fr.

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

Stop after this many charged rows. 0 means no limit.

## `minDelaySecs` (type: `integer`):

Google Trends limits requests per IP. The Actor waits at least this long between requests and slows down by itself when Google pushes back.

## `timeoutSecs` (type: `integer`):

Per request.

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

Not needed. Your own proxies can make very large runs faster, since Google's limit is per IP.

## Actor input object example

```json
{
  "keywords": [
    "coffee",
    "chatgpt vs gemini"
  ],
  "geo": "US",
  "timeRange": "today 12-m",
  "customTimeRange": "",
  "category": 0,
  "property": "",
  "includeRegions": true,
  "includeRelatedQueries": true,
  "trendingNowGeos": [
    "US"
  ],
  "language": "en-US",
  "maxItems": 0,
  "minDelaySecs": 2,
  "timeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Keyword rows with interest over time, averages, peak, change, interest by region and related queries; trending rows with title, traffic and news. Lines that could not be read appear with ok=false and a reason, and are not charged.

# 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",
        "chatgpt vs gemini"
    ],
    "geo": "US",
    "trendingNowGeos": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearfetch/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 = {
    "keywords": [
        "coffee",
        "chatgpt vs gemini",
    ],
    "geo": "US",
    "trendingNowGeos": ["US"],
}

# Run the Actor and wait for it to finish
run = client.actor("clearfetch/google-trends-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 '{
  "keywords": [
    "coffee",
    "chatgpt vs gemini"
  ],
  "geo": "US",
  "trendingNowGeos": [
    "US"
  ]
}' |
apify call clearfetch/google-trends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clearfetch/google-trends-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/aVg7LdaZNxlgjcQwh/builds/sBpAGZv2coAfkBEgv/openapi.json