# Google Trends Scraper - Compare Unlimited Keywords + Trending (`githubanassk/google-trends-scraper`) Actor

Google Trends API alternative: interest over time for any number of keywords on one shared scale, growth % and rising/falling verdict, interest by region, top and rising related queries, and Trending Now. No browser, fresh IP on every rate limit. $2 per 1,000 results, no start fee.

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

## Pricing

$2.00 / 1,000 results

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 unlimited keywords on one scale

Get Google Trends data as clean JSON, CSV or Excel. Put **any number of keywords on one shared 0–100 scale**, not just 5, and **keep small keywords accurate** next to giant ones. Each keyword also gets a **growth % and a rising/falling verdict**, interest by region, and the top and rising related searches. You can add **Trending Now** for any country in the same run.

**$2 per 1,000 results. No start fee.** One result is one keyword in one country, with its full timeline, regions and related queries included. A 10-keyword run costs $0.02.

### Why this one

- **More than 5 keywords at once.** Google Trends compares at most 5 terms. This actor chains comparisons through an anchor keyword and rescales them, so 50 keywords come back directly comparable. You can rank a whole keyword list by real search interest.
- **Small keywords stay accurate.** Google rounds to whole numbers relative to the biggest term, so next to `iphone` a niche keyword shows 0 or 1 and its comparison is mostly noise. This actor measures every keyword next to neighbours of similar size and chains those measurements, so a keyword 1,000× smaller than the top one still gets an exact decimal value (for example `0.0492`). In our live tests the chained ratios matched direct head-to-head measurements within about 1% for most pairs, and within about 7% for a keyword 400× smaller than its neighbour.
- **Daily data for up to 5 years.** Google only gives daily points for ranges under about 9 months, and anything longer is weekly. Turn on `dailyData` to also get a `dailyTimeline`: daily windows stitched together, with each window calibrated to the weekly curve of the whole range so they can't drift. That is useful for forecasting, finance and measuring a campaign day by day. It costs the same price.
- **Seasonality built in.** With 2+ years of data, every keyword gets `seasonality`: its peak month, its low month, and how strong the swing is.
- **Answers, not only numbers.** Every keyword comes with `growthPercent`, `trend` (`rising` / `stable` / `falling`), `peak`, `peakDate`, `average` and `latest`. Sort by growth and the breakout terms are at the top.
- **Built for Google's rate limits.** Google answers bursts of Trends requests with HTTP 429. When that happens, the actor drops the IP and cookie and retries from a fresh session with backoff, instead of failing the run. It uses no browser, so runs are fast and cheap.
- **You only pay for results.** There is no actor-start fee, and keywords that fail are not charged.

### What you get per keyword

| Field | Meaning |
|---|---|
| `keyword`, `geo`, `timeframe` | What was measured |
| `timeline` | `[{date, value}]` on the shared 0–100 scale across **all** your keywords |
| `average`, `peak`, `latest` | Size on the shared scale: how big this keyword is next to the others |
| `timelineOwnScale` | The same keyword measured alone at full 0–100 resolution, so even a tiny keyword next to a giant shows its real shape |
| `growthPercent`, `trend`, `peakDate` | Momentum from the full-resolution curve: last quarter of the period vs the first quarter; ±20% decides rising/falling. `growthPercent` is null when the keyword started from zero (it is then `rising`) |
| `interestByRegion` | Countries, states/provinces or US metro areas (DMA), 0–100 |
| `relatedQueriesTop`, `relatedQueriesRising` | What people also search; rising values such as `+350%` or `Breakout` |
| `dailyTimeline` | With `dailyData` on: daily points on the shared scale for ranges of 9 months to 5 years |
| `seasonality` | `{peakMonth, lowMonth, strengthPercent}` for 2+ years of data |
| `trendsUrl` | Opens the same view on trends.google.com |
| `lowPrecision` | `true` only when a keyword is over ~100× smaller than every other keyword in your list, so no similar-sized neighbour could be used to measure it |

The **Trending Now** rows contain `title`, `approxTraffic` (for example `200+`), `startedAt`, `picture`, and `news` (title, URL and source).

### Example input

```json
{
  "keywords": ["chatgpt", "claude", "gemini", "perplexity", "copilot", "deepseek", "grok"],
  "geos": ["US"],
  "timeframe": "today 3-m",
  "includeRelatedQueries": true,
  "trendingNowGeos": ["GB"]
}
```

### Example output (real run, 2026-10-10)

One keyword from a 12-keyword comparison:

```json
{
  "type": "keyword",
  "keyword": "gemini",
  "geo": "US",
  "timeframe": "today 3-m",
  "comparedKeywords": 12,
  "average": 26.4,
  "peak": 37,
  "latest": 26,
  "growthPercent": 35.8,
  "trend": "rising",
  "peakDate": "2026-10-01T00:00:00Z",
  "timeline": [
    {
      "date": "2026-07-10T00:00:00Z",
      "value": 23
    },
    {
      "date": "2026-07-11T00:00:00Z",
      "value": 20
    },
    "..."
  ],
  "timelineOwnScale": [
    63,
    54,
    55,
    64,
    62,
    60,
    "..."
  ],
  "lowPrecision": false,
  "interestByRegion": [
    {
      "geoCode": "US-CA",
      "geoName": "California",
      "value": 100
    },
    {
      "geoCode": "US-TX",
      "geoName": "Texas",
      "value": 88
    },
    "..."
  ],
  "relatedQueriesTop": [
    {
      "query": "gemini google",
      "value": "100"
    },
    {
      "query": "gemini ai",
      "value": "81"
    },
    "..."
  ],
  "relatedQueriesRising": [
    {
      "query": "gemini 4 argon",
      "value": "+3,800%"
    },
    {
      "query": "gemini argon",
      "value": "+1,650%"
    },
    "..."
  ],
  "trendsUrl": "https://trends.google.com/trends/explore?q=gemini&date=today+3-m&geo=US"
}
```

One Trending Now row:

```json
{
  "type": "trendingNow",
  "geo": "US",
  "title": "utah football",
  "approxTraffic": "1000+",
  "startedAt": "2026-10-09T20:20:00-07:00",
  "picture": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcTDIndspCaL9QC20d5cVJFHcohTUskJH3vDbPGkJ_o2gZmjra55sEllAgQaHI0",
  "news": [
    {
      "title": "Forecast pushes Utah-Kansas game to earlier kickoff",
      "url": "https://kutv.com/news/local/forecast-pushes-utah-kansas-game-to-earlier-kickoff",
      "source": "KUTV"
    }
  ]
}
```

### Use cases

- **SEO and content planning.** Paste 100 keyword ideas, sort by `average` for size and `growthPercent` for momentum, and write about the rising ones first.
- **Product and niche research.** Test product ideas for Etsy, Amazon or Shopify before you build them. Set Search type to Google Shopping to measure shopping intent.
- **Brand and competitor tracking.** Compare your brand against every competitor at once. Schedule a weekly run and watch the `trend` column.
- **Seasonality.** Use `today 5-y` and read `peakDate` to see when demand peaks each year, then plan launches and ad budgets around it.
- **Local demand.** Set Interest by region to Metro area (DMA) to find where demand is concentrated before you spend on local ads.
- **Newsjacking.** Add `trendingNowGeos` to get what is spiking right now, with the news stories behind it.

### Settings

- **Time range:** `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`, or `2024-01-01 2024-12-31`.
- **Countries:** `US`, `GB`, `DE`, a region code such as `US-CA`, or empty for worldwide. You get one result per keyword per country.
- **Category ID:** use Google's category IDs (0 is all). Examples: 71 is Food & Drink, 18 is Shopping, 958 is Jobs.
- **Proxy:** residential is the default and the most reliable for Google.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/githubanassk~google-trends-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["air fryer", "slow cooker", "instant pot"], "geos": ["US"], "timeframe": "today 5-y"}'
```

It also works from Python and JavaScript with the Apify client, and from Make, Zapier, n8n and Google Sheets through Apify integrations.

### FAQ

**How can more than 5 keywords share one scale?** First, a quick pass orders your keywords by size. Then every keyword is compared in a batch of up to 5 together with neighbours of similar size, and consecutive batches share one keyword. The shared keyword links each batch to the previous one through the ratio of its total interest, which cancels Google's per-point rounding. Finally, everything is normalized so the overall peak is 100. A tool that uses one fixed anchor term instead reduces every small keyword to 0–1.

**Why do small keywords have long decimals?** They are exact values on a scale where the biggest keyword peaks at 100. `0.0492` means about 1/2000th of the top keyword's peak. `timelineOwnScale` shows the same keyword alone at full 0–100 resolution, and `trend` and `growthPercent` are computed from it.

**How accurate is the daily data?** Each daily window is scaled to match the weekly curve of the whole range, so the level stays consistent across years. In our tests the 30-day blocks stayed within 1.5% of the true level, and on live 5-year runs the daily average matched the weekly average within about 4%. Single days carry Google's whole-number rounding.

**Related topics or city-level data?** Google currently returns both as empty through its data endpoints, so this actor returns related **queries** (top and rising) and country, state and metro-area breakdowns, which Google still serves.

**Is it legal?** The actor reads publicly available, aggregated Google Trends data and no personal data. Check your own use against Google's terms.

Questions or a missing field? Open an issue on the Issues tab. It is usually fixed within a day.

# Actor input Schema

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

Search terms to analyze. Add as many as you like: all of them are put on ONE shared 0-100 scale, so you can rank 50 keywords against each other (Google itself compares at most 5).

## `geos` (type: `array`):

Two-letter country codes such as US, GB, DE, or a region code such as US-CA. Leave empty for worldwide. Each country gives one result per keyword.

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

Google Trends time range: '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', or custom dates 'YYYY-MM-DD YYYY-MM-DD'.

## `dailyData` (type: `boolean`):

Google only gives daily points for ranges under about 9 months; longer ranges come back weekly. Turn this on to also get a dailyTimeline for ranges from 9 months to 5 years ('today 12-m', 'today 5-y' or custom dates), stitched from daily windows calibrated to the weekly curve. Slower, same price.

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

Which Google search to measure.

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

Google Trends category ID (0 = all categories). Example: 71 = Food & Drink, 18 = Shopping, 958 = Jobs.

## `regionLevel` (type: `string`):

Breakdown level for interest by region. 'Auto' gives countries for worldwide and states/provinces for a country. Metro area (DMA) gives US TV markets. 'Off' skips it.

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

Add the top and rising related searches for each keyword. Rising queries are the breakout searches people use to spot new trends early.

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

Optional. Two-letter country codes to also fetch what is trending right now (title, approximate search volume, start time, news articles). Works with or without keywords.

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

How many Google Trends requests run at once, each from its own IP.

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

Google rate-limits Trends hard. Residential proxies give the most reliable results; every rate-limited request is retried from a fresh IP.

## Actor input object example

```json
{
  "keywords": [
    "chatgpt",
    "claude",
    "gemini",
    "perplexity",
    "copilot",
    "deepseek"
  ],
  "geos": [
    "US"
  ],
  "timeframe": "today 12-m",
  "dailyData": false,
  "searchProperty": "",
  "category": 0,
  "regionLevel": "",
  "includeRelatedQueries": true,
  "trendingNowGeos": [],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per keyword and country: trend verdict, growth %, size on the shared scale, peak date and a link to Google Trends.

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

Every field: timelines on the shared and own scale, daily data, seasonality, regions, related queries and Trending Now rows.

# 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": [
        "chatgpt",
        "claude",
        "gemini",
        "perplexity",
        "copilot",
        "deepseek"
    ],
    "geos": [
        "US"
    ],
    "trendingNowGeos": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("githubanassk/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": [
        "chatgpt",
        "claude",
        "gemini",
        "perplexity",
        "copilot",
        "deepseek",
    ],
    "geos": ["US"],
    "trendingNowGeos": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("githubanassk/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": [
    "chatgpt",
    "claude",
    "gemini",
    "perplexity",
    "copilot",
    "deepseek"
  ],
  "geos": [
    "US"
  ],
  "trendingNowGeos": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call githubanassk/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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