# Google Trends Scraper — Unlimited Keywords (`ambitious_vagabond/google-trends-unlimited`) Actor

Compare any number of keywords on Google Trends on ONE common 0-100 scale (not just 5), plus interest by region, related queries and trending-now searches. Fast, reliable, pay per keyword.

- **URL**: https://apify.com/ambitious\_vagabond/google-trends-unlimited.md
- **Developed by:** [Ambitious Vagabond](https://apify.com/ambitious_vagabond) (community)
- **Categories:** SEO tools, Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### What does Google Trends Scraper — Unlimited Keywords do?

It gets **[Google Trends](https://trends.google.com/) data for any number of keywords — and puts all of them on one common 0–100 scale.** Google Trends only compares **5 keywords at a time**, and every comparison is scaled differently, so numbers from two comparisons can't be compared. This Actor does the stitching for you: 10, 50 or 500 keywords come back directly comparable, as if Google had compared them all at once.

For each keyword you get the **full interest-over-time timeline**, a **summary** (average, peak, latest value, trend), and optionally **interest by region** and **related queries**. It can also fetch **what's trending right now** in any country.

Run it in Apify Console, call it via **API**, schedule it, or plug it into **Make, Zapier, n8n, Google Sheets** or **AI agents (MCP)** — Apify handles proxies, retries and storage.

### Why use it?

- **Compare more than 5 keywords — correctly.** Rank 200 product names, brands, cities or topics by real search interest in one run.
- **Accurate for small keywords too.** Google rounds everything to whole numbers, so small keywords next to a big one show up as "<1" or 0. This Actor re-measures them next to smaller "bridge" keywords, so a keyword 1,000× smaller than your biggest one still gets a real number.
- **Reliable.** Google rate-limits Trends aggressively. The Actor rotates sessions and proxies and retries with backoff instead of failing your run.
- **Ready-to-use output.** A summary table for quick decisions, plus a one-row-per-date timeline view for charts and spreadsheets.

Typical uses: **keyword and content research, SEO, product and market research, brand tracking, seasonality analysis, picking names or locations, and feeding trend data to dashboards or AI agents.**

### How to use it

1. Click **Try for free**.
2. Enter your **search terms** — one per line, as many as you want.
3. Optionally pick a **location**, **time range**, **category** or **search type** (web, images, news, YouTube, Shopping).
4. Optionally tick **Interest by region** or **Related queries**, or add countries under **Trending now**.
5. Click **Start** and download the results as **JSON, CSV, Excel or HTML**, or get them via API.

### Input

Everything is in the **Input** tab. Example:

```json
{
    "searchTerms": ["chatgpt", "gemini", "claude", "perplexity", "deepseek", "copilot", "grok", "mistral ai"],
    "geo": "US",
    "timeRange": "today 12-m",
    "includeRelatedQueries": true,
    "trendingNowCountries": ["US", "GB"]
}
```

| Field | What it does |
|---|---|
| `searchTerms` | Keywords to compare. Any number — more than 5 are put on one common scale automatically. |
| `geo` | Country (`US`, `DE`, `LT`…) or sub-region (`US-CA`). Empty = worldwide. |
| `timeRange` | Past hour, 4 hours, day, 7 days, 30 days, 90 days, 12 months, 5 years, or 2004–present. |
| `customTimeRange` | Exact dates: `"2024-01-01 2024-12-31"`. |
| `category` | Google Trends category ID to disambiguate terms (0 = all). |
| `searchProperty` | Web search (default), image, news, YouTube or Google Shopping search. |
| `includeRegions` / `regionResolution` | Interest by country, region, city or US metro area. |
| `includeRelatedQueries` | Top and rising related searches. |
| `trendingNowCountries` | Also get today's trending searches (with news links) for these countries. |

### Output

One item per keyword. Example (shortened):

```json
{
    "type": "keyword",
    "keyword": "claude",
    "geo": "US",
    "timeRange": "today 12-m",
    "scale": "0-100, shared by all 8 keywords (100 = highest point of any keyword)",
    "average": 6.01,
    "max": 10.74,
    "peakDate": "2026-04-12",
    "latest": 9.8,
    "latestDate": "2026-09-13",
    "changePercent": 336.4,
    "trend": "rising",
    "precision": "high",
    "timeline": [
        { "date": "2025-09-21", "period": "Sep 21 – 27, 2025", "value": 2.31, "isPartial": false },
        { "date": "2025-09-28", "period": "Sep 28 – Oct 4, 2025", "value": 2.44, "isPartial": false }
    ],
    "relatedQueries": [
        { "rank": "top", "query": "claude ai", "value": 100, "formattedValue": "100", "link": "https://trends.google.com/trends/explore?q=claude+ai&date=today+12-m&geo=US" }
    ]
}
```

Trending-now items look like this:

```json
{
    "type": "trending",
    "geo": "US",
    "rank": 1,
    "title": "dow jones industrial average",
    "approxTraffic": "2000+",
    "approxTrafficMin": 2000,
    "startedAt": "2026-09-25T14:20:00-07:00",
    "news": [{ "title": "Stocks rally as…", "url": "https://…", "source": "Reuters" }]
}
```

The **Output** tab has ready-made views: **Keywords overview**, **Interest over time** (one row per keyword per date — ideal for charts and spreadsheets), **Interest by region**, **Related queries** and **Trending now**. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

#### Data fields

| Field | Meaning |
|---|---|
| `average`, `max`, `latest` | Interest on the common 0–100 scale (100 = the highest single point of any keyword in the run). |
| `peakDate`, `latestDate` | When the peak happened; the last complete period. |
| `changePercent`, `trend` | Last quarter of the period vs. the first quarter: `rising` (> +20 %), `falling` (< −20 %) or `stable`. |
| `precision` | How finely Google's data could measure this keyword: `high` (typically within ~1 %), `medium` (~5 %), `low` (~15 %), `too small` (below what Google reports at this scale), `no data`. |
| `timeline` | Every period: `date`, Google's `period` label, `value`, `isPartial` (the current, unfinished period). |
| `regions` | `geoName`, `geoCode`, `value` (0–100 within that keyword). |
| `relatedQueries` | `rank` (top / rising), `query`, `value`, `formattedValue` (e.g. "Breakout", "+250%"), `link`. |

### How much does it cost?

This Actor uses **pay-per-event** pricing — you pay only for results, not for compute time:

| Event | Price |
|---|---|
| Keyword (full timeline + summary) | **$2.00 per 1,000 keywords** |
| Extra data per keyword (regions or related queries, each) | $1.00 per 1,000 |
| Trending-now search | $1.00 per 1,000 |

Comparing 100 keywords costs **$0.20**. The Apify **free plan** includes monthly credits, enough for **thousands of keywords per month for free**. Set a **maximum charge per run** in the run options and the Actor will stop at that limit.

### Tips

- **Big lists are efficient**: on average about **1 Google request per keyword**, however many keywords you compare.
- Use a **category** for ambiguous words (e.g. "jaguar" in *Autos & Vehicles*, category 47).
- For long histories, **Past 5 years** gives weekly data and **2004–present** monthly data.
- If you see rate-limit retries in the log, lower **Parallel requests** — the run will be slower but smoother.

### How it works — and how accurate it is

1. A quick knockout round finds your most-searched keyword (the **anchor**).
2. Every other keyword is fetched next to the anchor, and each comparison is rescaled so the anchor matches — this puts all keywords on one scale.
3. Keywords that are tiny next to the anchor are re-measured next to smaller **bridge** keywords, cascading down, so they get real values instead of "<1".

(Step-by-step explanation of the method, including how to do it by hand: [How to compare more than 5 keywords in Google Trends](https://aivaras-mastermind.github.io/google-trends-guide/).)

In our tests the combined scale matched **Google's own side-by-side comparison within about 1–3 %** — the same size as Google's own rounding. Values can differ slightly from what you see on the Google Trends website, because Google samples searches and rounds to whole numbers.

### FAQ, disclaimers and support

**Is it legal to scrape Google Trends?** The Actor collects publicly available, **aggregated and anonymous** search-interest statistics — no personal data. You are responsible for how you use the data and for complying with Google's terms and applicable law.

**Why does a keyword show `precision: too small`?** Google reports whole numbers relative to the biggest point in each comparison. If a keyword is thousands of times smaller than every other keyword in your run, even the bridge re-measurement can't resolve it. Add a few mid-sized keywords, or run it separately.

**Does it return related *topics*?** No — Google currently returns an empty list for related topics through its data interface, so this Actor offers related **queries** only.

**Known limitation:** for a keyword with one huge spike (e.g. a one-day news event), its quiet periods can only be measured to about ±10 %, because Google scales every comparison to the highest point.

**Found a bug or need a feature?** Open an issue in the **Issues** tab — it's actively maintained. Need a custom data pipeline? Get in touch through the Issues tab.

# Actor input Schema

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

Keywords to compare — as many as you like. Google Trends only compares 5 at a time; with more, this Actor automatically puts all of them on one common 0–100 scale, so every value is comparable with every other.

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

Two-letter country code (e.g. US, DE, LT) or a sub-region like US-CA. Leave empty for worldwide.

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

Period to analyse. Ignored if a custom time range is set.

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

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

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

Google Trends category ID to narrow ambiguous terms (0 = all categories). Examples: 5 Computers & Electronics, 7 Finance, 12 Business & Industrial, 45 Health, 18 Shopping, 20 Sports, 67 Travel.

## `searchProperty` (type: `string`):

Which Google search to measure.

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

Add each keyword's interest by country / region / city.

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

Level of the regional breakdown. Automatic = countries for worldwide, regions within a country otherwise.

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

Add the top and rising related search queries for each keyword.

## `trendingNowCountries` (type: `array`):

Optional: also get what people are searching for right now in these countries (two-letter codes, e.g. US, GB, DE). Works with or without search terms.

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

Google Trends rate-limits heavily; the Actor rotates sessions automatically. Apify Proxy is recommended.

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

How many Google Trends requests run in parallel (1–5). Lower is gentler and less likely to be rate-limited.

## Actor input object example

```json
{
  "searchTerms": [
    "chatgpt",
    "gemini",
    "claude"
  ],
  "geo": "",
  "timeRange": "today 12-m",
  "category": 0,
  "searchProperty": "",
  "includeRegions": false,
  "regionResolution": "",
  "includeRelatedQueries": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("ambitious_vagabond/google-trends-unlimited").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",
        "claude",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ambitious_vagabond/google-trends-unlimited").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",
    "claude"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call ambitious_vagabond/google-trends-unlimited --silent --output-dataset

```

## MCP server setup

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

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/uFBihTojREn6HzqGS/builds/SUzro9Fzx221quwgN/openapi.json