# Google Trends Scraper – Compare up to 2,000 Keywords (`baendito/google-trends-pro`) Actor

Google Trends data for any keyword list: interest over time, by region, related & rising queries, trend direction. Web, YouTube, News, Images and Shopping. Put 50+ keywords on one 0-100 scale, plus Trending Now by country.

- **URL**: https://apify.com/baendito/google-trends-pro.md
- **Developed by:** [bæendito](https://apify.com/baendito) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 search term analyzeds

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 – Compare up to 2,000 Keywords

Get **Google Trends data for a whole keyword list in one run**: interest over time, interest by region, top and rising related queries, and a ready-made trend verdict (rising / stable / falling) for every term. Works for **Web search, YouTube, Google News, Google Images and Google Shopping**, any country or region, any period from the past hour to 2004.

Google Trends only lets you compare **5 terms at a time**. This Actor can put **10, 50 or 500 terms on one common 0–100 scale** and rank them, which Google Trends itself doesn't do.

### What you get

| Data | Details |
|---|---|
| **Interest over time** | Every data point Google shows (hourly, daily, weekly or monthly, depending on the period), with partial points flagged |
| **Summary numbers** | Average, latest, peak value and peak date, % change (latest quarter vs earliest quarter of the period), trend direction |
| **Interest by region** | Countries, regions/states, cities or US metro areas (DMA), sorted by interest |
| **Related queries** | Top queries and rising queries with their growth (`+250%`, `Breakout`) – ideal for keyword research |
| **Common-scale comparison** | Up to 2,000 terms on one scale, plus a popularity ranking |
| **Trending now** | The full list from trends.google.com/trending for any country (often 300+ trends a day in large countries): search volume, % increase, start/end time, active or not, categories and the searches that make up each trend. Filter by past 4 h / 24 h / 48 h / 7 days and by category |
| **Search types** | Web, YouTube, News, Images, Shopping |
| **Link** | A `trendsUrl` that opens the same view on trends.google.com, so you can check any number yourself |

### Why this Actor

- **Built for Google's rate limits.** Google Trends answers bursts of requests with HTTP 429. Each parallel worker has its own proxy session and cookie and switches to a fresh IP when Google blocks it, so runs keep going instead of stalling.
- **No hanging runs.** The Actor watches the run timeout and stops cleanly before it, saving everything it has already collected. You are only charged for terms that were delivered.
- **Verified against Google Trends.** The interest-over-time values match the data trends.google.com shows in the browser, point for point (we check this with a real browser, see *How accurate is it?*).
- **Spreadsheet-friendly.** Choose *one row per term* (with summary columns) or *one row per term and date* to chart it straight away in Excel or Google Sheets.
- **Honest output.** When Google has no data for part of a request, the term gets a `warnings` field that explains what is missing.

### How to use it

1. Enter your **search terms**, one per line.
2. Choose a **location** (`US`, `GB`, `ES`, `US-CA`, or empty for worldwide), a **time range** and the **search type**.
3. Optional: turn on **Compare all terms on one scale**.
4. Click **Start**. Download the results as JSON, CSV, Excel or HTML, or call the Actor from the API, Make, Zapier, n8n or an AI agent (MCP).

#### Example input

```json
{
  "searchTerms": ["chatgpt", "gemini", "claude", "perplexity", "copilot", "deepseek", "grok"],
  "geo": "US",
  "timeRange": "today 12-m",
  "property": "web",
  "compareOnSameScale": true
}
```

#### Example output (one term, shortened)

```json
{
  "searchTerm": "bitcoin",
  "geo": "ES",
  "timeRange": "today 3-m",
  "periodResolved": "2026-06-26 2026-09-26",
  "dataResolution": "DAY",
  "property": "web",
  "averageInterest": 49.83,
  "latestInterest": 48,
  "peakInterest": 100,
  "peakDate": "2026-08-21T00:00:00.000Z",
  "trendChangePercent": -6.6,
  "trendDirection": "stable",
  "topRegion": "La Rioja",
  "topRelatedQuery": "precio bitcoin",
  "topRisingQuery": "how to buy bitcoin safely",
  "interestOverTime": [
    { "date": "2026-06-26T00:00:00.000Z", "formattedTime": "Jun 26, 2026", "value": 70, "hasData": true, "isPartial": false }
  ],
  "interestByRegion": [
    { "geoCode": "ES-RI", "geoName": "La Rioja", "value": 100 },
    { "geoCode": "ES-NC", "geoName": "Navarre", "value": 82 }
  ],
  "relatedQueriesTop": [
    { "query": "precio bitcoin", "value": 100, "formattedValue": "100", "isBreakout": false, "link": "https://trends.google.com/trends/explore?q=precio+bitcoin&date=today+3-m&geo=ES" }
  ],
  "relatedQueriesRising": [
    { "query": "how to buy bitcoin safely", "value": 700, "formattedValue": "+700%", "isBreakout": false, "link": "https://trends.google.com/trends/explore?q=how+to+buy+bitcoin+safely&date=today+3-m&geo=ES" }
  ],
  "trendsUrl": "https://trends.google.com/trends/explore?date=today+3-m&geo=ES&q=bitcoin&hl=en-US"
}
```

#### Example Trending now item

```json
{
  "geo": "US",
  "rank": 1,
  "title": "oklahoma vs georgia",
  "searchVolume": 500000,
  "searchVolumeLabel": "500K+",
  "increasePercent": 1000,
  "startedAt": "2026-09-26T18:40:00.000Z",
  "endedAt": null,
  "isActive": true,
  "categories": ["Sports"],
  "trendBreakdown": ["ole miss vs florida", "texas tennessee", "florida football", "…"],
  "trendsUrl": "https://trends.google.com/trends/explore?q=oklahoma%20vs%20georgia&date=now%201-d&geo=US"
}
```

In common-scale mode each term also has a `commonScale` object (`anchorTerm`, `scaleFactor`, `rank`), and each timeline point keeps Google's original value in `rawValue`. The ranking is also saved in the **RUN_SUMMARY** record of the key-value store.

### Pricing

Pay only for results:

| Event | Price |
|---|---|
| One search term analyzed (all selected data for that term) | **$0.002** ($2 per 1,000 terms) |
| One *Trending now* search | **$0.0005** ($0.50 per 1,000) |

Terms that fail or are skipped are **not charged**. Set a *maximum cost per run* in the run options and the Actor stops cleanly when it is reached.

### How the common scale works

Google normalizes every request so the highest point is 100, which is why numbers from different requests can't be compared. The Actor splits your list into groups of 5 that all share one **anchor term**, then rescales each group so the anchor has the same values everywhere, and finally rescales everything so the highest point of all terms is 100.

- For up to 5 terms this is exactly Google's own comparison.
- Pick an anchor of medium-to-high popularity (option *Anchor term*). If the anchor is tiny next to a much bigger term in the same group, Google rounds it to 0–1 and precision drops. The Actor flags those terms with a *Low precision* warning.
- Google rounds each value to a whole number, so terms that are 1,000 times smaller than the biggest term will show values near 0. That's a limit of Google Trends itself.

### FAQ

**How accurate is it?** The Actor reads the same JSON that the Google Trends website loads. We compared a 93-day series point by point with the values trends.google.com served to a real browser for the same search, and all 93 matched. Google Trends is based on a sample of searches, so values for small terms can change slightly between days. This is how Google Trends works, not an error.

**Do I need a proxy?** Google rate-limits datacenter IPs quickly, so the default is Apify's **residential proxy**. If your account doesn't have it, the Actor falls back to the default proxy automatically.

**Why are related topics empty?** Google currently returns empty *related topics* lists for most searches, including on its own website, so that option is off by default. *Related queries* work normally.

**What do the values mean?** 100 is the peak popularity for the term in the chosen place and period, 50 means half as popular, and 0 means not enough data. They are relative numbers, not search volumes.

**Can I use it from an AI agent?** Yes. Call it through the Apify MCP server or the API. The summary fields (`trendDirection`, `trendChangePercent`, `topRisingQuery`) are designed to be read by LLMs without processing the full timeline.

**Is Trending now the same list as on the website?** Yes. It reads the same data that trends.google.com/trending loads, and the category filter works the same way (we checked that the number of trends per category matches the website's menu for all 20 categories). If that call ever fails, the Actor falls back to Google's short RSS feed (about 10 trends per country) and logs a warning.

**What are the limits?** Up to 2,000 terms per run. Each term needs 2–5 requests to Google (depending on the data you choose), and Google slows down clients that ask too fast, so for lists of several hundred terms raise the run timeout or split the list. If the timeout gets close, the Actor stops cleanly and keeps what it has.

### Legal

This Actor only reads public, aggregated and anonymous data from Google Trends and the public Trending Now RSS feed. It doesn't collect any personal data. It isn't affiliated with or endorsed by Google. Check that your use complies with Google's terms and the law where you live.

# Actor input Schema

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

Keywords to analyze, one per line. Each term gets its interest over time, interest by region and related queries. Up to 2,000 terms per run.

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

Two-letter country code (US, GB, ES, DE, BR...), a region such as US-CA or ES-MD, or empty for worldwide.

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

Period to analyze. Ignored when a custom time range is set.

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

Optional. Exact dates as "YYYY-MM-DD YYYY-MM-DD", e.g. "2024-01-01 2024-12-31". Overrides the time range above.

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

Which Google search to measure: regular web search, YouTube, Google News, Google Images or Google Shopping.

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

Optional Google Trends category number to narrow ambiguous terms (e.g. 7 = Finance, 71 = Food & Drink, 18 = Shopping). 0 = all categories.

## `compareOnSameScale` (type: `boolean`):

Google Trends compares at most 5 terms at a time. Turn this on to put ALL your terms (10, 50, 500...) on one common 0-100 scale and get a popularity ranking. Each term is charged once, as usual.

## `anchorTerm` (type: `string`):

Term used to link the groups of 5 onto one scale. Defaults to your first term. Best results with a term of medium-to-high popularity among your list.

## `includeInterestByRegion` (type: `boolean`):

Where the term is most searched (countries, regions, cities or metro areas).

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

Level of detail for interest by region. Auto = countries for worldwide, regions (states/provinces) for a country.

## `includeLowVolumeRegions` (type: `boolean`):

Also list regions with little search volume.

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

Top related searches and rising searches (with growth like +250% or Breakout). Great for keyword research.

## `includeRelatedTopics` (type: `boolean`):

Top and rising related topics. Note: Google currently returns empty topic lists for most searches, so this is off by default.

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

Optional. The full Trending Now list for these countries (e.g. US, GB, ES), as on trends.google.com/trending: search volume, % increase, start/end time, active status, categories and the related searches that make up each trend. Works with or without search terms.

## `trendingHours` (type: `string`):

Trends that started in this window.

## `trendingCategory` (type: `string`):

Only keep trends in this category.

## `trendingActiveOnly` (type: `boolean`):

Skip trends that have already ended.

## `maxTrendingPerGeo` (type: `integer`):

Keep the top N trends per country (Google's own ranking). 0 = all of them (often 300+ for large countries over 24 hours).

## `outputFormat` (type: `string`):

One row per term (with summary numbers and nested data) or one row per term and date (easy to chart in Excel / Google Sheets; contains the interest-over-time table only).

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

Interface language for labels such as dates and region names, e.g. en-US, es-ES, de-DE.

## `maxConcurrency` (type: `integer`):

How many terms are analyzed at the same time, each through its own proxy session.

## `maxRetries` (type: `integer`):

When Google rate-limits a request, the Actor switches to a fresh IP and retries up to this many times.

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

Google Trends rate-limits datacenter IPs quickly. Residential proxy is recommended; the Actor falls back to the default proxy if it is not available.

## Actor input object example

```json
{
  "searchTerms": [
    "chatgpt",
    "gemini",
    "claude"
  ],
  "geo": "",
  "timeRange": "today 12-m",
  "property": "web",
  "category": 0,
  "compareOnSameScale": false,
  "includeInterestByRegion": true,
  "regionResolution": "AUTO",
  "includeLowVolumeRegions": false,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "trendingHours": "24",
  "trendingCategory": "0",
  "trendingActiveOnly": false,
  "maxTrendingPerGeo": 100,
  "outputFormat": "perTerm",
  "language": "en-US",
  "maxConcurrency": 3,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "searchTerms": [
        "chatgpt",
        "gemini"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("baendito/google-trends-pro").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 = {
    "searchTerms": [
        "chatgpt",
        "gemini",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("baendito/google-trends-pro").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 '{
  "searchTerms": [
    "chatgpt",
    "gemini"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call baendito/google-trends-pro --silent --output-dataset

```

## MCP server setup

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

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/pK8FMT2LxwyDeCH6j/builds/Mu1kcKmJ7zjXAugGX/openapi.json