# Google Trends Scraper: Compare Unlimited Keywords (`bisketapis/google-trends-scraper`) Actor

Google Trends for unlimited keywords on one comparable 0-100 scale (auto-stitched past Google's 5-term limit). Interest over time, regions, cities, related queries and topics, YouTube/Shopping/News search, Trending Now. Per-keyword trend summary. No browser, pay only for results.

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

## Pricing

from $2.00 / 1,000 keyword reports

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 for **any number of keywords, all on one comparable 0-100 scale**. Google's own tool compares only 5 terms at a time, and every request is rescaled so its own peak is 100, which means numbers from two different comparisons can't be compared. This Actor fixes that automatically: it links the batches through a shared anchor keyword and rescales everything onto one scale. Paste 50 keywords and see which ones really get more searches.

For every keyword you get:

- 📈 **Interest over time** (hourly to monthly points, 2004 to today)
- 🗺️ **Interest by region**: country, state, metro area (DMA) or city
- 🔎 **Related queries**: top and rising, with Breakout flags
- 🧩 **Related topics**: top and rising (optional; returned when Google provides them, which it often doesn't right now)
- 📊 **A trend summary**: average, latest, peak and peak date, change over the period, year-over-year change, momentum, breakout flag and seasonal peak month
- 📄 **One CSV with every timeline** (dates as rows, keywords as columns), ready for Excel or Google Sheets

There's also a **Trending Now** mode: today's rising searches for any country, with approximate search volume, growth %, start time, category and related searches. That's usually 300-700 trends per country per day, not the 10-20 the RSS feed gives you.

#### Why this Actor

| | This Actor | Typical Google Trends scrapers |
|---|---|---|
| More than 5 keywords on one scale | ✅ automatic | ❌ separate scales, or "do it yourself" |
| Speed | 7-9 keywords in ~10-20 s; 100 keywords in ~60-80 s | minutes per keyword with browser-based scrapers |
| Approach | Direct HTTP to the Trends data endpoints, no browser | Often a headless browser that waits for page widgets |
| Failed keywords | Not charged, and listed in the run summary | Often charged, or the whole run fails |
| Trend summary per keyword | ✅ | ❌ raw data only |
| YouTube, Shopping, News and Image search | ✅ | sometimes |
| Proxy cost | included in the price | sometimes billed on top |

#### How the stitching works

With more than 5 keywords, the Actor:

1. Asks Google for the first 5 keywords and picks the most popular one as the **anchor** (or uses the `anchorKeyword` you set).
2. Asks for the remaining keywords in groups of 4, plus the anchor each time.
3. Rescales each group so the anchor matches its value in the first group, then rescales everything so the overall peak is 100.

In our tests, stitched values matched Google's own direct comparisons to within 0-3.5%. The small differences come from Google rounding to whole numbers.

Google rounds inside each request, so a small keyword compared with a giant one ("excel formulas" next to "chatgpt") comes back as zero. The Actor spots these cases and asks again, this time next to an already-measured keyword of similar size, then rescales through it. In a 100-keyword test across 5 countries, that cut zero rows by up to 100% and removed every low-precision row, for about 5-8% more requests. Each row includes a `stitch` object with the batch number, scale factor and a quality grade (`high` / `medium` / `low`). If an anchor is tiny compared with a much bigger keyword, the row gets a warning. Set a mid-sized `anchorKeyword` to fix it.

#### Input example

```json
{
    "searchTerms": ["air fryer", "instant pot", "slow cooker", "rice cooker", "pressure cooker", "toaster oven", "sous vide"],
    "geo": "US",
    "timeRange": "today 5-y",
    "searchType": "web",
    "compareMode": "together",
    "includeRegions": true,
    "regionResolution": "REGION",
    "includeRelatedQueries": true
}
```

Trending Now:

```json
{ "mode": "trendingNow", "geo": "GB", "trendingHours": "24", "trendingCategories": ["Sports"], "maxItems": 100 }
```

#### Output example (one keyword; arrays trimmed to 1-2 items)

A real row from the input example above:

```json
{
    "keyword": "rice cooker",
    "geo": "US",
    "timeRange": "today 5-y",
    "searchType": "web",
    "category": 0,
    "scale": "shared",
    "comparedWith": [
        "air fryer",
        "instant pot",
        "slow cooker",
        "pressure cooker",
        "toaster oven",
        "sous vide"
    ],
    "average": 5.98,
    "latest": 7,
    "peak": 13,
    "peakDate": "2026-06-21",
    "low": 4,
    "changePct": 76.4,
    "yoyChangePct": 0,
    "momentumPct": -13.8,
    "trendDirection": "rising",
    "isBreakout": false,
    "peakMonth": "Jan",
    "topRelatedQuery": "rice in rice cooker",
    "topRisingQuery": "best rice cooker 2023",
    "points": 262,
    "timeline": [
        {
            "date": "2026-10-18",
            "value": 7,
            "isPartial": false
        },
        {
            "date": "2026-10-25",
            "value": 6,
            "isPartial": true
        }
    ],
    "regions": [
        {
            "geoCode": "US-HI",
            "geoName": "Hawaii",
            "value": 100
        },
        {
            "geoCode": "US-WY",
            "geoName": "Wyoming",
            "value": 77
        }
    ],
    "relatedQueriesTop": [
        {
            "query": "rice in rice cooker",
            "value": 100,
            "formattedValue": "100",
            "isBreakout": false,
            "link": "https://trends.google.com/trends/explore?q=rice+in+rice+cooker&date=today+5-y&geo=US"
        }
    ],
    "relatedQueriesRising": [
        {
            "query": "best rice cooker 2023",
            "value": 12900,
            "formattedValue": "Breakout",
            "isBreakout": true,
            "link": "https://trends.google.com/trends/explore?q=best+rice+cooker+2023&date=today+5-y&geo=US"
        }
    ],
    "stitch": {
        "batch": 0,
        "anchor": "air fryer",
        "scaleFactor": 1,
        "anchorMeanInBatch": 57.1,
        "quality": "high",
        "isAnchor": false,
        "localMean": 5.98
    },
    "exploreUrl": "https://trends.google.com/trends/explore?q=rice+cooker&date=today+5-y&geo=US",
    "warnings": [],
    "scrapedAt": "2026-10-25T04:22:43Z"
}
```

Trending Now row (GB):

```json
{
    "rank": 2,
    "title": "chelsea vs spurs",
    "geo": "GB",
    "searchVolume": 200000,
    "increasePct": 1000,
    "startedAt": "2026-10-24T13:30:00Z",
    "endedAt": null,
    "isActive": true,
    "categories": ["Sports"],
    "relatedQueries": ["chelsea vs spurs", "chelsea f.c. vs tottenham standings", "chelsea", "cole palmer"],
    "exploreUrl": "https://trends.google.com/trends/explore?q=chelsea+vs+spurs&geo=GB&date=now%207-d"
}
```

The **Keyword overview** table view shows the summary columns. `TIMELINE.csv` in the run's key-value store has every timeline side by side, and `OUTPUT` lists the status of each keyword.

#### What can you use Google Trends data for?

- **SEO and content planning**: rank a keyword list by real search interest, spot rising queries before the competition, and time content to the seasonal peak month.
- **Product research and e-commerce**: compare products on Google Shopping search, find which states or cities want them most, and catch breakout products early.
- **YouTube strategy**: compare video topics by YouTube search interest.
- **Market and brand tracking**: track your brand against competitors on one scale. Schedule the Actor weekly and watch momentum.
- **News and social teams**: pull Trending Now every few hours for content ideas.
- **AI agents and automations**: clean flat JSON, a summary row per keyword, and simple inputs. Works through the Apify API, MCP, Make, n8n and Zapier.

#### Pricing

You pay per result: one **keyword report** (everything above for one keyword) or one **trending search**. Proxy and compute are included. Keywords that fail aren't charged. If you set a spending limit on the run, the Actor stops before going over it and lists the keywords it skipped.

#### Tips

- **Values are relative, not search counts.** Google Trends shows relative interest (0-100), not absolute volume. Trending Now's `searchVolume` is Google's own approximate figure.
- **Compare like with like.** In `together` mode every value compares across keywords in the same run. To compare against a later run, keep the same anchor keyword.
- **Ambiguous words**: set a `category` (for example 71 = Food & Drink) to separate "apple" the fruit from Apple the company.
- **Low-volume terms** may return all zeros. That's Google saying "not enough data", not an error, and the row carries a warning.
- **Few regions for small keywords?** Like trends.google.com, regions with too few searches are left out by default, because their values are noisy. Turn on `includeLowVolumeRegions` to get every region.

#### FAQ

**Is it legal to scrape Google Trends?** The Actor reads public, aggregated, anonymized data that anyone can see on trends.google.com. No personal data is collected. Check that your use complies with Google's terms and your local laws.

**Why can numbers differ slightly from the website?** Google samples its data, so two identical requests made hours apart can differ by a point or two. Stitched values also carry Google's whole-number rounding.

**How many keywords can I send?** As many as you like. Large lists run in parallel; raise `maxConcurrency` (up to 10) for speed.

**Something not working?** Open an issue on the Issues tab with your run link. We read every one.

# Actor input Schema

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

Keywords: a full Google Trends report for each search term. Trending Now: today's rising searches in one country (search volume, growth, related searches).

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

Keywords to look up. Any number: with more than 5, every keyword is still put on ONE comparable 0-100 scale (we stitch Google's 5-term batches through a shared anchor keyword). Not needed for Trending Now.

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

Two-letter country code (US, GB, DE, IN...), or a region code like US-CA or GB-ENG. Leave empty for Worldwide.

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

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

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

Optional. Two dates separated by a space: 2024-01-01 2024-12-31

## `searchType` (type: `string`):

Which Google property's searches to measure.

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

Google Trends category to narrow ambiguous terms (0 = all categories). Examples: 71 Food & Drink, 18 Shopping, 7 Finance, 5 Computers & Electronics, 8 Games.

## `compareMode` (type: `string`):

Together: all keywords on one shared scale, so the numbers compare across keywords (stitched automatically past 5). Separate: each keyword on its own 0-100 scale, like searching it alone.

## `anchorKeyword` (type: `string`):

Used only with more than 5 keywords. The shared term that links the batches. Leave empty to auto-pick the most popular term of the first batch. It may be a term outside your list; then it is used for scaling only and not returned or charged.

## `includeTimeline` (type: `boolean`):

Full time series per keyword. All timelines are also saved together as TIMELINE.csv.

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

Where the keyword is searched most.

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

Granularity of interest by region. Worldwide searches always use countries. Metro (DMA) is US only.

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

Off matches trends.google.com: regions with too few searches are left out, because their values are noisy (small states often show 100). Turn on to get every region.

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

Searches related to each keyword, including Breakout terms.

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

Topics related to each keyword. Needs one extra request per keyword when comparing several, so it is off by default.

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

Trending searches that started in the past 4 hours, 24 hours, 48 hours or 7 days.

## `trendingOnlyActive` (type: `boolean`):

Skip trends Google marks as ended.

## `trendingCategories` (type: `array`):

Optional filter, e.g. Sports, Entertainment, Technology, Shopping, Business and Finance, Politics, Health, Games.

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

Most popular first. 0 = all (often 300-700 per country per day).

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

Interface language for names of regions and topics, e.g. en-US, de, es, fr, ja.

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

How many Google sessions run at once. Higher is faster for long keyword lists.

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

Google rate-limits by IP. Residential proxy (default) keeps runs reliable. Proxy traffic is included in the price.

## Actor input object example

```json
{
  "mode": "keywords",
  "searchTerms": [
    "air fryer",
    "instant pot",
    "slow cooker",
    "rice cooker",
    "pressure cooker",
    "toaster oven",
    "sous vide"
  ],
  "geo": "US",
  "timeRange": "today 12-m",
  "searchType": "web",
  "category": 0,
  "compareMode": "together",
  "includeTimeline": true,
  "includeRegions": true,
  "regionResolution": "REGION",
  "includeLowVolumeRegions": false,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "trendingHours": "24",
  "trendingOnlyActive": false,
  "maxItems": 100,
  "language": "en-US",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One row per keyword (or per trending search).

## `timelineCsv` (type: `string`):

Date rows x keyword columns, all on the same scale. Keyword mode only.

## `runSummary` (type: `string`):

Status per keyword (ok / failed / skipped), stitching details, request stats.

# 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": [
        "air fryer",
        "instant pot",
        "slow cooker",
        "rice cooker",
        "pressure cooker",
        "toaster oven",
        "sous vide"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bisketapis/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 = { "searchTerms": [
        "air fryer",
        "instant pot",
        "slow cooker",
        "rice cooker",
        "pressure cooker",
        "toaster oven",
        "sous vide",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bisketapis/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 '{
  "searchTerms": [
    "air fryer",
    "instant pot",
    "slow cooker",
    "rice cooker",
    "pressure cooker",
    "toaster oven",
    "sous vide"
  ]
}' |
apify call bisketapis/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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