# Google Trends Scraper — Reliable with Regions & Trending Now (`datasprout/google-trends-reliable`) Actor

Scrape Google Trends reliably: interest over time, by region, related & breakout queries, plus insights and summaries. Export JSON or CSV. Pay per report.

- **URL**: https://apify.com/datasprout/google-trends-reliable.md
- **Developed by:** [Tomas Maciulevičius](https://apify.com/datasprout) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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 — Reliable, With Insights, Regions, Related & Trending Now

Get Google Trends data for any keyword in one run: **interest over time**, **interest by country, region, city or US metro**, **related queries and topics (top, rising and breakout)** and **today's trending searches** — plus **ready-made insights**: the peak, the latest value, recent momentum, where it's most popular and which searches are breaking out, written up in plain English.

### Why this one

- **Built for Google's rate limits.** When Google pushes back, the Actor switches to a fresh residential IP and cookie, backs off and retries — up to 8 times per request by default. Warm sessions are reused across keywords, so long lists stay fast and cheap.
- **Answers, not just numbers.** Every report includes `insights` (peak, latest, % change, direction, top regions, breakout searches) and a `summary` paragraph — ideal for dashboards, newsletters and AI agents.
- **Many countries in one run.** List `US`, `DE`, `GB`, `US-CA`… and get a report for each.
- **Spreadsheet mode.** Switch output to flat rows for clean CSV / Excel / Google Sheets exports.
- **Never pay for broken data.** Incomplete reports are delivered free, marked with `missingSections`.
- **Respects your spending limit** and stops cleanly when it's reached.

### What you get

| Data | What it tells you |
|---|---|
| Interest over time | Search interest (0–100) for every hour, day, week or month in the period |
| Insights & summary | Average, peak date, latest value, recent change %, rising / falling / stable |
| Interest by region | Where each term is searched most: countries, regions/states, cities or US DMAs |
| Related queries | Top and rising searches made alongside each term; "Breakout" = growth above 5000% |
| Related topics | Top and rising topics, with Google Knowledge Graph IDs |
| Trending now | Today's trending searches per country, with traffic estimates and news links |

Works for web, image, news, Google Shopping and YouTube search, every category, and any period from the past hour to 2004–today.

### How to use it

1. Add **search terms** (plain keywords, or topic IDs such as `/m/05p0rrx`).
2. Add **countries or regions**, or leave empty for worldwide.
3. Pick a **time range**.
4. Turn on **Compare terms** to put up to 5 terms on one shared 0–100 scale, or leave it off for a separate report per term.
5. Optionally add countries under **Trending now**.
6. Run. Each report shows its title and summary in the **Reports** view; open JSON for every data point. A run summary is saved as `OUTPUT` in the key-value store.

#### Example input

```json
{
  "searchTerms": ["bitcoin", "ethereum", "solana"],
  "compareTerms": true,
  "geos": ["US", "DE"],
  "timeRange": "today 12-m",
  "trendingNowGeos": ["US", "GB"]
}
```

#### Example output (keyword report, shortened)

```json
{
  "type": "keywordReport",
  "title": "bitcoin vs ethereum · US · The past 12 months",
  "summary": "Most searched overall: \"bitcoin\". \"bitcoin\": averaged 61/100 in US over the past 12 months, peaking on 2025-11-09; latest value 58 (up 21% in the most recent quarter of the period: rising). Most popular in Nevada, Wyoming, Colorado. Breakout searches: bitcoin etf options. …",
  "insights": {
    "bitcoin": {
      "averageInterest": 61.4,
      "peak": { "date": "2025-11-09T00:00:00Z", "value": 100 },
      "latest": { "date": "2026-10-04T00:00:00Z", "value": 58 },
      "recentChangePercent": 21.0,
      "direction": "rising",
      "topRegions": [{ "name": "Nevada", "value": 100 }],
      "topQueries": ["bitcoin price", "btc"],
      "risingQueries": [{ "query": "bitcoin etf options", "growth": "Breakout" }],
      "breakoutQueries": ["bitcoin etf options"],
      "topTopics": ["Bitcoin", "Cryptocurrency"]
    }
  },
  "searchTerms": ["bitcoin", "ethereum"],
  "geo": "US",
  "timeRange": "today 12-m",
  "interestOverTime": [
    { "date": "2025-10-12T00:00:00Z", "formattedTime": "Oct 12 – 18, 2025", "values": { "bitcoin": 58, "ethereum": 17 }, "isPartial": false }
  ],
  "averageInterest": { "bitcoin": 61.4, "ethereum": 18.2 },
  "regionResolution": "REGION",
  "interestByRegion": [{ "geoCode": "US-NV", "geoName": "Nevada", "values": { "bitcoin": 100, "ethereum": 31 } }],
  "relatedQueries": {
    "bitcoin": {
      "top": [{ "query": "bitcoin price", "value": 100, "formattedValue": "100", "link": "https://trends.google.com/trends/explore?..." }],
      "rising": [{ "query": "bitcoin etf options", "value": 5000, "formattedValue": "Breakout", "link": "..." }]
    }
  },
  "relatedTopics": { "bitcoin": { "top": [{ "topic": "Bitcoin", "topicType": "Currency", "topicId": "/m/05p0rrx", "value": 100 }], "rising": [] } },
  "trendsUrl": "https://trends.google.com/trends/explore?date=today+12-m&q=bitcoin%2Cethereum&geo=US",
  "scrapedAt": "2026-10-14T13:00:00Z"
}
```

#### Spreadsheet rows

With **Output format → Spreadsheet rows**, each report becomes flat rows with a `type` column: `termSummary` (one per term, with the insights), `timelinePoint`, `regionInterest`, `relatedQuery` and `relatedTopic`. Export as CSV or Excel and filter by `type`. The price is the same as one report.

#### Trending now

```json
{
  "type": "trendingSearch",
  "geo": "US",
  "rank": 1,
  "title": "world cup",
  "approxTraffic": "2M+",
  "approxTrafficNumber": 2000000,
  "publishedAt": "2026-10-14T15:00:00Z",
  "news": [{ "title": "Final tonight", "url": "https://...", "source": "BBC" }]
}
```

### Use it from AI agents

Connect it through the Apify MCP server and ask your agent things like *"How has interest in heat pumps changed in Germany over the past 5 years, and what are the breakout searches?"* The `summary` and `insights` fields give the agent the answer directly, without crunching 260 data points.

### Use it from code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_USERNAME/google-trends-reliable").call(run_input={
    "searchTerms": ["electric bike"],
    "geos": ["US", "GB"],
    "timeRange": "today 5-y",
})
for report in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(report["title"], "→", report["summary"])
```

### Pricing

You pay per **keyword report** — one per term, or one per comparison group, per location — and per **trending search**. Proxy and compute costs are included. Partial reports are free. Set a maximum cost per run and the Actor stops cleanly when it's reached.

### Tips

- **Values are relative.** 100 is the peak for the chosen terms, place and period — not a search count. Turn on Compare terms to put several terms on the same scale.
- **"Breakout"** means the query grew by more than 5000% in the period.
- **Low-volume terms** can return empty data; the summary will say so. That's Google not having enough data, not an error.
- **Partial periods:** the last point is often incomplete (`isPartial: true`) and is left out of the insights.
- **Use residential proxies** (the default). Datacenter IPs get rate-limited quickly.

### FAQ

**How many keywords can I run at once?** As many as you like — they're processed in parallel sessions (3 by default, up to 10).

**Can I compare more than 5 terms?** Google allows 5 per comparison; longer lists are split into groups of 5, each with its own scale.

**Which category IDs exist?** Open Google Trends, pick a category, and copy the number after `cat=` in the URL.

**Is it legal?** The Actor reads publicly available, aggregated, non-personal statistics from Google Trends. Check Google's terms and the rules that apply to your use.

### Feedback

Found a problem or want another field? Open an issue on the Issues tab — fixes usually ship within days.

# Actor input Schema

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

Keywords or phrases to look up. You can also use Google Knowledge Graph topic IDs such as /m/05p0rrx (Bitcoin the topic), which Google treats more precisely than plain text.

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

On: terms share one 0–100 scale, in groups of up to 5 (Google's limit) — use this to see which term is bigger. Off: every term gets its own report and its own scale.

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

Two-letter country codes (US, DE, LT) or regions (US-CA, GB-ENG). Each location gets its own report. Leave empty for worldwide; add WORLDWIDE to include it alongside countries.

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

Period to analyse. Choose Custom to set exact dates below.

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

Used only when Time range is Custom. Dates: "2024-01-01 2024-12-31". Hours (UTC, within the past week): "2026-10-10T08 2026-10-12T20".

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

Google Trends category to search in (0 = all). Find the ID in the cat= part of a Trends URL, e.g. 7 = Finance, 5 = Computers & Electronics.

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

Which Google search to measure.

## `includeInterestOverTime` (type: `boolean`):

Timeline of search interest (0–100), with peak, latest value and recent momentum calculated for you.

## `includeInterestByRegion` (type: `boolean`):

Where each term is searched most.

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

Automatic picks countries for worldwide searches, regions/states for a country, and cities for a region.

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

Also return regions with little search volume.

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

Top and rising searches people make alongside each term, including "Breakout" queries (growth over 5000%).

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

Top and rising related topics, with Knowledge Graph IDs.

## `outputFormat` (type: `string`):

Reports: one rich JSON item per term (best for APIs and AI agents). Spreadsheet rows: one flat row per date, region, query and topic (best for CSV, Excel and Google Sheets). The price is the same.

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

Two-letter country codes (US, GB, DE…). Returns today's trending searches with traffic estimates and news links. Works with or without search terms.

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

Language for topic names and date labels, e.g. en-US, de, lt.

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

How many reports to fetch at once, each through its own IP. Higher is faster for long lists but invites more rate-limiting.

## `maxAttemptsPerRequest` (type: `integer`):

How many fresh IPs to try when Google rate-limits a request.

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

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

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin",
    "ethereum"
  ],
  "compareTerms": false,
  "timeRange": "today 12-m",
  "category": 0,
  "searchProperty": "web",
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "regionResolution": "AUTO",
  "includeLowVolumeRegions": false,
  "includeRelatedQueries": true,
  "includeRelatedTopics": true,
  "outputFormat": "reports",
  "language": "en-US",
  "maxConcurrency": 3,
  "maxAttemptsPerRequest": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `reports` (type: `string`):

No description

## `rows` (type: `string`):

No description

## `trending` (type: `string`):

No description

## `summary` (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": [
        "bitcoin",
        "ethereum"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasprout/google-trends-reliable").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": [
        "bitcoin",
        "ethereum",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datasprout/google-trends-reliable").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": [
    "bitcoin",
    "ethereum"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call datasprout/google-trends-reliable --silent --output-dataset

```

## MCP server setup

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

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/9Ky0OzLshPS6hxk6A/builds/PybKYvBTDTcXt6eIF/openapi.json