# Google Trends Scraper Pro (`lsso/google-trends-scraper-pro`) Actor

Google Trends API alternative: compare unlimited keywords on one scale, get daily data for years, regions, related and breakout queries, plus Trending Now with news. Built-in breakout/rising/seasonality detection and forecasts. Pay only for results.

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

## Pricing

from $10.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 Pro: unlimited keywords, daily history, trend detection & Trending Now

**A Google Trends API alternative that answers the question, not just the numbers.** Compare any number of keywords on one scale, get true daily data for multi-year ranges, and see instantly which topics are **breaking out, rising, peaking or declining**, with seasonality and a forecast. Plus live **Trending Now** searches with volume, growth and news. No API key, no login.

- ✅ **No comparison limit.** Google Trends compares at most 8 terms at a time (5 in classic explore) and rescales every comparison to 0–100, so numbers from different comparisons can't be put side by side. This Actor chains requests through calibrated **anchor keywords** (the G-TAB method from academic research) and puts 10, 50 or 200 keywords on **one shared scale**. Low-volume terms are re-measured against smaller anchors so they don't collapse to 0 or 1.

- ✅ **Daily data for years, not weekly.** Google switches to weekly points after ~9 months. Turn on *Daily data* and the Actor fetches overlapping windows and **stitches** them into one consistent daily series (validated at r = 0.996 against Google's own weekly curve).

- ✅ **Trend analysis built in.** Every keyword gets a status (**breakout / rising / stable / peaked / declining**), growth over the last month and quarter, year-over-year change, momentum, peak date, spike/drop detection, **seasonality** (busiest and quietest months) and a short **forecast with an 80% range**, plus a one-line plain-English summary.

- ✅ **Interest by region, related & rising queries**, with **breakout queries** pulled out separately (the +5000% searches that signal a new trend).

- ✅ **Paste Google Trends URLs**: copy links from trends.google.com and the Actor reads keywords, location, period, category and search type from them. Moving from another scraper takes one paste.

- ✅ **Spreadsheet-ready**: choose the *flat* layout for one row per keyword per date, ready for Google Sheets, Excel or Looker Studio.

- ✅ **Trending Now** for any country **or state/region** (`US-CA`, `US-NY`, `GB-ENG`…): search volume, % increase, start/end time, active or ended, category, related searches and **news articles with images for every trend**.

- ✅ **Monitoring mode** for schedules: reports status changes and **new rising queries since the last run**.

- ✅ **Visual HTML report** with charts in every run, and a **SerpApi-compatible JSON** so you can switch without rewriting code.

- ✅ **Reliable and fair**: residential proxies, fresh IP on every rate limit, automatic backoff. Keywords Google has no data for are **not charged**.

***

### 🎬 60-second demo

https://www.youtube.com/watch?v=ISqQnSiEW70

***

### 🚀 Quick start

1. Enter your **Keywords** (as many as you like), e.g. `ChatGPT`, `Gemini`, `Claude`.
2. Optionally set **Location** (`US`, `GB`, `KR`… or empty for worldwide) and **Time range**.
3. Click **Start**. Results appear in the **Output** tab; open **Visual report** for the charts.

For live trending searches, switch **What do you want?** to **Trending Now** and pick countries.

### 💡 What people use it for

- **SEO & content planning**: find which topics are rising before competitors do; plan posts around seasonal peaks.
- **E-commerce & product research**: spot breakout products, compare hundreds of product names on one scale, time inventory to seasonality.
- **Market & investment research**: track brand or ticker interest daily over years; get alerted when a status changes.
- **Newsrooms & social media**: see what's trending right now in any country, with the news behind each trend.
- **AI agents & data pipelines**: clean JSON per keyword with a ready-made summary sentence.

### ⬇️ Input examples

Compare many keywords over 5 years:

```json
{
  "keywords": ["ChatGPT", "Gemini", "Claude", "Perplexity", "DeepSeek", "Grok", "Copilot", "Midjourney", "Cursor AI", "Suno"],
  "timeRange": "today 5-y"
}
```

Two years of **daily** data for the US:

```json
{
  "keywords": ["bitcoin", "ethereum"],
  "geo": "US",
  "startDate": "2024-09-01",
  "endDate": "2026-09-20",
  "dailyData": true
}
```

Straight from Google Trends links, one row per date for a spreadsheet:

```json
{
  "trendsUrls": ["https://trends.google.com/trends/explore?date=today%2012-m&geo=US&q=chatgpt,gemini,claude"],
  "outputLayout": "flat"
}
```

What's trending now in the US and South Korea:

```json
{ "mode": "trendingNow", "trendingGeos": ["US", "KR"], "trendingHours": 24, "maxTrendingItems": 100 }
```

### ⬆️ Output (one item per keyword)

```json
{
  "keyword": "Claude",
  "geo": "US",
  "timeRange": "today 12-m",
  "rank": 3,
  "status": "declining",
  "summary": "Claude: DECLINING +1.32% in the last 4 weeks, -24.85% in the last 12 weeks. Peak 34 on 2026-05-24.",
  "averageInterest": 18.06,
  "analysis": {
    "resolution": "week", "latest": 19, "peak": 34, "peakDate": "2026-05-24",
    "growthPct": 1.32, "quarterGrowthPct": -24.85, "yoyPct": null, "momentum": -17.06,
    "anomaly": null,
    "seasonality": null,
    "forecast": [{ "date": "2026-11-08", "value": 17.44, "low": 5.58, "high": 29.29 }]
  },
  "timeline": [{ "date": "2025-09-21T00:00:00.000Z", "value": 5, "isPartial": false }],
  "regions": [{ "geoCode": "US-CA", "geoName": "California", "value": 100 }],
  "relatedQueries": {
    "top": [{ "query": "claude ai", "value": 100, "formatted": "100" }],
    "rising": [{ "query": "claude cowork", "value": 3650, "formatted": "Breakout", "breakout": true }]
  },
  "breakoutQueries": ["claude cowork", "claude fable 5", "openclaw"],
  "scale": { "sharedWith": 3, "anchor": null, "relativeError": "0.88%", "stitched": false }
}
```

Trending Now items:

```json
{
  "title": "kratom", "geo": "US", "searchVolume": 200000, "increasePercentage": 1000,
  "active": true, "startedAt": "2026-09-22T19:40:00.000Z", "endedAt": null,
  "categoryNames": ["Other"],
  "breakdown": ["kratom", "what is kratom", "kratom drug"],
  "news": [{ "title": "Kratom found at locations where two students were discovered dead", "source": "NBC News", "url": "https://…", "publishedAt": "2026-09-23T…", "image": "https://…" }],
  "trendsUrl": "https://trends.google.com/trends/explore?geo=US&date=now%207-d&q=kratom"
}
```

Also saved in the run's key-value store:

| Record | What it is |
|---|---|
| `REPORT` | Self-contained HTML report with charts, statuses and rising queries |
| `OUTPUT` | Run summary: ranking of all keywords, resolution, stitching details |
| `SERPAPI_FORMAT` | `interest_over_time`, `interest_by_region`, `related_queries` in SerpApi's shape |

### 📊 How the status is decided

| Status | Rule of thumb |
|---|---|
| **Breakout** | Recent level ≥ 3× the level before it, up > 30% this quarter, peak is recent and still climbing |
| **Rising** | Up > 20% over the last month or quarter with positive momentum |
| **Peaked** | Peak was in the second half of the period and interest is now < 70% of it and falling |
| **Declining** | Down > 20% over the last month or quarter (or > 30% year over year) with negative momentum |
| **Stable** | None of the above |

Seasonality needs about 2 years of data; forecasts use a damped trend model with the seasonal pattern when one is found.

### 🔬 How "one shared scale" works

Google normalises every request so the biggest term = 100. Values from different requests are on different scales, and small terms get rounded to 0 or 1. The Actor:

1. measures the first 5 keywords together (the reference scale);
2. measures the rest in groups of 4 plus one **anchor** already on the reference scale, choosing the anchor closest in size so rounding error stays small;
3. re-measures keywords that came out tiny against a smaller anchor, and re-fetches the shape of low-volume terms alone for full resolution;
4. rescales everything so the global maximum is 100 and reports the estimated error per keyword (`scale.relativeError`).

In our tests the chained values matched direct Google comparisons within ~1% for similarly-sized terms.

### 💰 Pricing

| Event | Price |
|---|---|
| One keyword report (timeline + regions + related queries + analysis, on one shared scale) | **$0.01** |
| One Trending Now item (with news) | **$0.001** |

No subscription. **Keywords Google has no data for are free**, and a run that fails is not charged. Set a maximum cost per run in Apify and the Actor stops cleanly when it's reached.

### 🤖 Use it from AI agents (MCP): Claude, Cursor & any MCP client

This Actor works as a ready-made **connector for AI assistants**. Add one URL and your agent can call it on its own:

```
https://mcp.apify.com?tools=lsso/google-trends-scraper-pro
```

- **Claude** (claude.ai / Claude Desktop): *Settings → Connectors → Add custom connector*, paste the URL above, sign in to Apify.
- **Cursor / VS Code / any MCP client**: add it to your MCP config:

```json
{ "mcpServers": { "google-trends": { "url": "https://mcp.apify.com?tools=lsso/google-trends-scraper-pro" } } }
```

- **Claude Code**: `claude mcp add --transport http google-trends "https://mcp.apify.com?tools=lsso/google-trends-scraper-pro"`

Sign-in uses Apify OAuth in the browser, so you never paste a token into the config. Then just ask:

> *"Compare ChatGPT, Gemini, Claude, Perplexity and DeepSeek in the US over the last 12 months. Which one is rising?"*

> *"What is trending on Google in South Korea right now, and why?"*

> *"Give me 3 years of daily search interest for air fryer and tell me its peak season."*

Each keyword comes back with a one-line `summary` and a `status` (breakout / rising / stable / peaked / declining), so the agent can answer without crunching the time series itself. You pay only for results, same as a normal run.

### ❓ FAQ

**Is this the official Google Trends API?** No. Google's API is in limited alpha. This Actor reads the same public data that trends.google.com shows.

**Why do my numbers differ slightly from the website?** Google samples searches, so values can move by a point or two between requests. Shared-scale values are also rescaled so the largest keyword in *your* list is 100.

**Can I use topics instead of words?** Yes, put a topic ID like `/m/0d6lp` in *Keywords* (copy it from a trends.google.com URL).

**How often can I run it?** As often as you like. For monitoring, create an Apify **schedule** (e.g. daily) with *Monitoring mode* on and connect email, Slack or a webhook.

**Rate limits?** Handled for you: each request uses a fresh residential IP after a 429, with exponential backoff and up to 6 retries.

**Where are "related topics"?** As of September 2026 Google returns an empty list for related topics through its data endpoints, so the Actor doesn't charge you for an empty field. Related and rising **queries** work fully.

**I typed a wrong country code.** The run stops immediately with a clear message (for example `"USA" is not a valid location`) instead of quietly returning worldwide data.

### 📝 Changelog

- **1.1** (2026-09-24): Google Trends URLs as input; flat one-row-per-date layout for spreadsheets; sub-national Trending Now (`US-CA`…); location codes are validated.
- **1.0**: Unlimited keywords on one scale (G-TAB anchors), stitched daily data, trend status + forecast, regions, related & breakout queries, Trending Now with news, monitoring mode, HTML report, SerpApi-compatible JSON.

Found a bug or need a feature? Open an issue on the **Issues** tab. We usually reply within a day.

# Actor input Schema

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

**Keyword research**: interest over time, regions, related & breakout queries and trend analysis for your keywords. **Trending Now**: what people are searching right now in one or more countries, with search volume, growth and news.

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

Search terms or Google topic IDs (e.g. `/m/0d6lp`). **No comparison limit**: Google Trends compares at most 8 terms at once and rescales each comparison separately; here any number of keywords are placed on one shared 0–100 scale automatically (anchor calibration), so values are directly comparable across the whole list.

## `trendsUrls` (type: `array`):

Explore URLs copied from trends.google.com, e.g. `https://trends.google.com/trends/explore?date=today%2012-m&geo=US&q=chatgpt,gemini`. Keywords, location, period, category and search type are read from each URL (overriding the fields below). Handy if you already have a list of Trends links.

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

Two-letter country code (`US`, `GB`, `DE`, `KR`, `JP`…) or region code (`US-CA`, `GB-ENG`). Leave empty for worldwide. Invalid codes are rejected with a clear message instead of silently returning worldwide data.

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

Preset period. Ignored when both *Start date* and *End date* are set.

## `startDate` (type: `string`):

Custom range start (YYYY-MM-DD). Use together with *End date*.

## `endDate` (type: `string`):

Custom range end (YYYY-MM-DD).

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

Google only gives weekly/monthly points for ranges over ~9 months. Turn this on to get **true daily values** for multi-year ranges: the Actor fetches overlapping windows and stitches them onto one consistent scale (up to 5 keywords). Costs the same per keyword, takes longer.

## `include` (type: `array`):

Extra data per keyword.

## `outputLayout` (type: `string`):

`flat` returns one dataset row per keyword and date (`keyword, date, value, isPartial, status`), ready for spreadsheets and dashboards. Billing is the same (per keyword).

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

Google Trends category to disambiguate a term, e.g. `0` all, `5` Computers & Electronics, `7` Finance, `16` News, `18` Shopping, `44` Beauty & Fitness, `71` Food & Drink, `3` Arts & Entertainment. Full list: the `cat=` value in a trends.google.com URL.

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

Which Google search to measure.

## `analytics` (type: `boolean`):

Adds a status per keyword (**breakout / rising / stable / peaked / declining**), growth, year-over-year change, momentum, peak date, spike/drop detection, seasonality (busiest and quietest months) and a short forecast with an 80% range.

## `forecastHorizon` (type: `integer`):

How many future points to forecast (in the series' own resolution: days, weeks or months). Leave empty for a sensible default.

## `monitor` (type: `boolean`):

Remembers the last run for the same keywords + location + time range and reports **status changes** and **new rising queries** since then. Ideal with an Apify schedule and an email/Slack integration.

## `maxKeywords` (type: `integer`):

Safety cap on how many keywords are processed.

## `maxRegions` (type: `integer`):

How many regions to return per keyword, sorted by interest.

## `trendingGeos` (type: `array`):

Country or region codes for Trending Now, e.g. `US`, `GB`, `IN`, `KR`, `JP`, `DE`, `BR`, and sub-national regions such as `US-CA`, `US-NY` or `GB-ENG`.

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

Trends started in the past…

## `maxTrendingItems` (type: `integer`):

Maximum trends returned per country, highest search volume first.

## `onlyActive` (type: `boolean`):

Skip trends that have already ended.

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

Keep only these Trending Now categories (empty = all).

## `includeNews` (type: `boolean`):

Add the news headlines, sources and images Google shows next to each trend.

## `newsPerTrend` (type: `integer`):

How many news articles to attach to each trend (1–10).

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

Language for topic names and news, e.g. `en-US`, `ko`, `ja`, `de`.

## `timezoneOffset` (type: `integer`):

Minutes from UTC as Google expects it (UTC−5 → `300`, UTC+9 → `-540`). Affects hourly/daily bucket boundaries.

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

On rate limits the Actor switches to a fresh residential IP and backs off.

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

Residential proxies are strongly recommended; Google rate-limits datacenter IPs.

## Actor input object example

```json
{
  "mode": "explore",
  "keywords": [
    "ChatGPT",
    "Gemini",
    "Claude"
  ],
  "trendsUrls": [],
  "geo": "",
  "timeRange": "today 12-m",
  "dailyData": false,
  "include": [
    "timeline",
    "regions",
    "relatedQueries"
  ],
  "outputLayout": "nested",
  "category": 0,
  "property": "",
  "analytics": true,
  "monitor": false,
  "maxKeywords": 200,
  "maxRegions": 250,
  "trendingGeos": [
    "US"
  ],
  "trendingHours": "24",
  "maxTrendingItems": 100,
  "onlyActive": false,
  "trendingCategories": [],
  "includeNews": true,
  "newsPerTrend": 3,
  "language": "en-US",
  "timezoneOffset": 0,
  "maxRetries": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `serpapi` (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 = {
    "keywords": [
        "ChatGPT",
        "Gemini",
        "Claude"
    ],
    "trendingGeos": [
        "US"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lsso/google-trends-scraper-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 = {
    "keywords": [
        "ChatGPT",
        "Gemini",
        "Claude",
    ],
    "trendingGeos": ["US"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lsso/google-trends-scraper-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 '{
  "keywords": [
    "ChatGPT",
    "Gemini",
    "Claude"
  ],
  "trendingGeos": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call lsso/google-trends-scraper-pro --silent --output-dataset

```

## MCP server setup

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