# Google Trends Scraper — Rising Searches & Breakouts (`brilliant_gum/google-trends-scraper`) Actor

Track search demand on Google Trends: interest over time, interest by region, and the rising related searches Google flags as Breakout. Compare up to 5 terms on one scale, or list what a country is searching right now. No login, no API key.

- **URL**: https://apify.com/brilliant\_gum/google-trends-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 trend 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Trends Scraper — Rising Searches, Regions & Breakouts

![Google Trends Scraper](https://i.imgur.com/0nQZmp7.png)

Find out whether demand for something is growing or dying — and what people are searching *instead*.

No Google account, no API key. Google Trends has no official public API; this reads the same data the site does.

***

### What makes this different

Most Google Trends scrapers hand you the interest curve and stop there. The curve tells you *what happened*. The rising searches tell you *what happens next* — and nobody else on the Store returns them.

| | Typical scraper | This scraper |
|---|---|---|
| Interest over time | ✓ | ✓ |
| Interest by region | ✓ | ✓ |
| **Related searches (top)** | — | **✓** |
| **Rising searches + Breakout flags** | — | **✓** |
| **Compare up to 5 terms on one scale** | one term at a time | **✓** |
| Trend direction, computed | — | **✓** |

#### The Breakout signal

Google marks a related search as **Breakout** when it grows faster than a percentage can express — typically a term that barely existed weeks ago. It is the earliest demand signal Trends offers, and it comes free with every term you analyse.

A real result from testing `claude ai`:

```
claude ai — SURGING +430%
   ↑ claude cowork    Breakout
   ↑ openclaw         Breakout
   ↑ antigravity      Breakout
   ↑ opencode         +2,250%
```

Three product names that were nothing a month earlier. That is what you are buying.

#### Direction, not just numbers

Every term is classified so you can filter and sort without doing the maths:

| Label | Meaning |
|---|---|
| `SURGING` | +50% or more |
| `RISING` | +15% to +50% |
| `STABLE` | within ±15% |
| `DECLINING` | −15% to −50% |
| `COLLAPSING` | −50% or worse |

Comparison is against the same window a year apart, ignoring the in-progress bucket that always reads as a dip.

**`trendConfidence` tells you whether to believe the percentage.** Google rounds its index to whole numbers, so a term averaging 2 out of 100 moves in 50% steps by definition — testing `reebok` returned "SURGING +54%" off an average interest of 2, which is rounding noise, not demand. Read `HIGH` (average ≥15) as trustworthy, `MEDIUM` (5–14) as directional, and `LOW` (under 5) as too small to call.

***

### Quick start

```json
{
  "searchTerms": ["chatgpt", "claude ai"]
}
```

That is the whole input. Terms share one 0-100 scale, exactly like the comparison view on Google Trends.

***

### What you get

An unedited record, trimmed for length:

```json
{
  "searchTerm": "claude ai",
  "trend": "SURGING",
  "changePercent": 430,
  "latestInterest": 4,
  "averageInterest": 3,
  "peakInterest": 6,
  "peakDate": "Apr 5, 2026",
  "topRegion": "Madagascar",
  "topRelatedQuery": "claude code",
  "breakoutQueries": ["claude cowork", "openclaw", "antigravity"],
  "breakoutCount": 3,
  "risingQueryCount": 25,
  "interestOverTime": [
    { "date": "Aug 10, 2025", "timestamp": "2025-08-10T00:00:00.000Z", "value": 1, "isPartial": false }
  ],
  "interestByRegion": [
    { "geoCode": "MG", "geoName": "Madagascar", "value": 100, "hasData": true }
  ],
  "relatedQueries": {
    "top":    [{ "query": "claude code", "value": 100, "formattedValue": "100" }],
    "rising": [{ "query": "claude cowork", "formattedValue": "Breakout", "isBreakout": true }]
  },
  "geo": "Worldwide",
  "timeframe": "today 12-m",
  "scrapedAt": "2026-08-16T21:06:50.000Z"
}
```

Measured coverage over 12 months: **54 data points**, **80–88 regions**, **13–25 top** and **5–25 rising** related searches per term.

***

### Two modes

#### Analyse search terms

```json
{
  "searchTerms": ["electric car", "hybrid car", "petrol car"],
  "timeframe": "today 5-y",
  "geo": "DE",
  "includeRelatedQueries": true
}
```

Up to five terms are charted together on one scale. Pass more and they are split into batches of five — values stay comparable inside a batch, not across batches, and the log says so.

Set `compareTerms: false` to measure each term on its own scale instead. Use that when terms are unrelated, otherwise a big term flattens a small one to near-zero.

#### Trending right now

```json
{
  "mode": "trending",
  "trendingGeo": "GB",
  "trendingLimit": 20
}
```

Returns what a country is searching today, with approximate traffic and the news stories driving it.

***

### Inputs worth knowing

| Input | Why it matters |
|---|---|
| `timeframe` | Shorter ranges give finer data: hours return minute-level points, a year returns weekly |
| `customTimeframe` | Exact window, e.g. `"2026-01-01 2026-06-30"` |
| `geo` | `US`, `DE`, or a sub-region like `US-CA` for California. Empty = Worldwide |
| `category` | Disambiguates a word — `jaguar` in Autos is a different search from `jaguar` in Pets |
| `includeSuggestions` | Google's own autocomplete topics; helps tell the company from the animal |

Turning off `includeRegions` or `includeRelatedQueries` makes runs noticeably faster when you only need the curve.

***

### Use cases

- **SEO and content** — find rising searches before they are competitive, and see which existing terms are decaying.
- **Product and market research** — compare demand for competing products, features or brands on one scale.
- **Market entry** — `interestByRegion` shows where demand actually sits before you commit spend.
- **Trend spotting** — breakout queries surface product names and topics weeks before they show up in the news.
- **Seasonality planning** — five years of history reveals when demand peaks each year.
- **Newsrooms** — trending mode gives what a country is searching right now, with source articles.

***

### Honest limitations

These come from Google Trends itself, not from the scraper.

**Values are relative, never absolute.** 100 means "the highest point in this query", not a search volume. Trends never publishes real counts — anyone claiming to give you them is estimating.

**Low-volume terms return nothing.** Google withholds data below a traffic threshold. The record still comes back with the term and settings, all data fields empty — a nonsense term in testing returned exactly that. Try a broader term, a longer timeframe, or Worldwide instead of one country.

**Comparison changes the numbers.** With `compareTerms: true`, a term that is small next to a giant will read near zero — that is the point of a shared scale, not an error. Turn comparison off to measure it alone.

**The latest bucket is incomplete.** The current week or day is still filling and always looks like a drop. Those points are marked `isPartial: true` and excluded from the trend calculation.

**Trending news varies by country.** The US feed carries source articles and images; some countries return the trending terms only. Nothing to be done about it from this side.

**Related searches need volume.** Terms with thin traffic often return an empty rising list.

**Google rate-limits, and a single section can be lost.** Runs rotate connections and retry, but occasionally one widget still fails while the rest succeed. When that happens the affected record carries `incompleteSections` (e.g. `["relatedQueries"]`) and the log says which term was hit — rather than silently returning a record that looks complete. Re-run to fill the gap.

***

### FAQ

**Do I need a Google account or API key?**
No. Nothing to configure.

**Are proxies included?**
Yes, automatically. Leave the Proxy field empty.

**How fast is it?**
Two terms with everything enabled: about 15 seconds. Seven terms: under three minutes. Trending: under 20 seconds.

**Can I get actual search volumes?**
No — and neither can anyone else. Google Trends publishes a 0-100 relative index only.

**Why is my term all zeros?**
Either it is below Google's volume threshold, or it is being compared against a much larger term. Try `compareTerms: false`.

**Can I track a term over time?**
Schedule the actor. Each run stamps `scrapedAt`, so successive runs build a history Google itself does not keep.

**Which countries work?**
All of them, plus sub-regions like `US-CA` or `GB-ENG`.

***

Maintained by **brilliant\_gum**. Issues and feature requests welcome on the Issues tab.

# Actor input Schema

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

Analyse search terms, or list what is trending in a country right now.

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

Terms to analyse, e.g. \["electric car", "hybrid car"]. Google puts up to 5 terms on one shared 0-100 scale so they can be compared directly.

## `compareTerms` (type: `boolean`):

On: terms share one scale, so 100 means the single most-searched point among them — this is how Google's own comparison works. Off: each term is measured on its own scale, which is what you want for unrelated terms.

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

How far back to look. Shorter ranges give finer granularity: hours give minute-level data, a year gives weekly.

## `customTimeframe` (type: `string`):

Overrides the time range above. Format: "2026-01-01 2026-06-30".

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

ISO code, e.g. "US", "GB", "DE". Sub-regions work too, e.g. "US-CA" for California. Leave empty for Worldwide.

## `category` (type: `string`):

Narrow results to one Google Trends category. Useful when a word means different things in different fields — "jaguar" in Autos vs in Animals.

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

The search-interest curve, plus average, peak value and peak date.

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

Where the term is searched most, ranked by relative interest. Shows which markets actually care.

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

What else people search alongside this term. Includes the rising list, where Google flags searches growing so fast it labels them Breakout — the strongest early signal Trends offers.

## `includeSuggestions` (type: `boolean`):

Google's own autocomplete topics for the term, useful for disambiguating (the company vs the animal). Adds one request per term.

## `trendingGeo` (type: `string`):

Country code for trending searches, e.g. "US", "GB", "IN". Used only in "Trending right now" mode.

## `trendingLimit` (type: `integer`):

Maximum trending searches to return.

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

Optional. Proxies are included and configured automatically — leave this empty.

## Actor input object example

```json
{
  "mode": "keywords",
  "searchTerms": [
    "nike",
    "adidas"
  ],
  "compareTerms": true,
  "timeframe": "today 12-m",
  "customTimeframe": "2026-01-01 2026-06-30",
  "geo": "US",
  "category": "0",
  "includeTimeline": true,
  "includeRegions": true,
  "includeRelatedQueries": true,
  "includeSuggestions": false,
  "trendingGeo": "GB",
  "trendingLimit": 20
}
```

# Actor output Schema

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

One-line recap of what the run found.

## `dataset` (type: `string`):

One item per analysed search term, or per trending search.

## `keyValueStore` (type: `string`):

Run-level rollup: trend distribution, strongest and weakest term, and every breakout query found.

## `consoleUrl` (type: `string`):

Open this run in Apify Console.

# 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 = {
    "mode": "keywords",
    "searchTerms": [
        "chatgpt",
        "claude ai"
    ],
    "compareTerms": true,
    "timeframe": "today 12-m",
    "includeTimeline": true,
    "includeRegions": true,
    "includeRelatedQueries": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/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 = {
    "mode": "keywords",
    "searchTerms": [
        "chatgpt",
        "claude ai",
    ],
    "compareTerms": True,
    "timeframe": "today 12-m",
    "includeTimeline": True,
    "includeRegions": True,
    "includeRelatedQueries": True,
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/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 '{
  "mode": "keywords",
  "searchTerms": [
    "chatgpt",
    "claude ai"
  ],
  "compareTerms": true,
  "timeframe": "today 12-m",
  "includeTimeline": true,
  "includeRegions": true,
  "includeRelatedQueries": true
}' |
apify call brilliant_gum/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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