# Google Trends Scraper – Fast, Reliable API Alternative (`rt-solutions/google-trends-scraper`) Actor

Google Trends data without failed runs: interest over time, by region, city and metro, related queries and topics (top & rising), Trending now with search volume. Compare long keyword lists on one scale. Drop-in replacement for the official scraper's input and output.

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

## Pricing

from $1.05 / 1,000 search analyseds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 – Fast, Reliable API Alternative

Get **Google Trends data without failed runs**: interest over time, interest by region, city and metro area, related queries and related topics (top and rising), plus today's **Trending now** searches with search volume. No browser, no login, no API key.

**Already using the official Google Trends Scraper?** This Actor accepts the **same input fields** and returns the **same output fields** (`interestOverTime_timelineData`, `interestBySubregion`, `relatedQueries_top`…). In most cases you only change the Actor ID in your code or integration.

### Why this one

| | This Actor | Typical browser-based scraper |
|---|---|---|
| How it works | Google Trends' own data endpoints | Opens Google Trends in a headless browser |
| Time per search term | ~5–25 s | 60–180 s |
| Refused requests | Retried automatically with a new IP address and cookie | Run often fails or loops |
| Never hangs | Every search has a time limit; partial data is kept and labelled | Can run until timeout |
| Compared terms | Related queries for **each** term | Often only one term |
| Long keyword lists on one scale | ✅ Anchor term | ❌ |
| Trend metrics (growth, peak, direction) | ✅ | ❌ |
| Trending now with search volume | ✅ | ❌ |
| Price | **$1.50 per 1,000 searches** | $3+ per 1,000 |

**Benchmark (20 Oct 2026, 5 keywords, US, past 12 months):** this Actor returned complete data for **5/5 keywords in 100 s** — time series, 51 states, cities, 210 metro areas and 50 related queries each. Other Google Trends Actors tested the same day returned partial data (time series only), ignored the keyword, or cost about $0.05 per keyword.

### What you get

**Keywords mode** — one item per search term (or per group of up to 5 compared terms):

- `interestOverTime_timelineData` — the chart, point by point (weekly for 12 months, daily for 90 days, hourly for 7 days…)
- `interestOverTime_averages` — average per compared term
- `interestBySubregion` — by state / region (by country when Worldwide)
- `interestByCity` — by city (single term, inside a country; tick *Include low search volume regions* for many more cities)
- `interestByMetro` — by US metro area (DMA)
- `relatedQueries_top`, `relatedQueries_rising` — with "Breakout" and +% growth
- `relatedTopics_top`, `relatedTopics_rising`
- `trendSummary` — **computed for you**: average, peak and peak date, latest value, change in % (last quarter of the period vs first quarter), direction (rising / stable / falling), low-volume flag
- `exploreUrl` — open the same chart in Google Trends

**Trending now mode** — what people search today, per country:

- search term, **search volume** (e.g. 200,000+), **increase %**, start time, still trending or not
- related search terms, categories (Sports, Politics, Entertainment…), news articles for the top trends

### Input examples

Simple:

```json
{ "searchTerms": ["air fryer", "standing desk"], "geo": "US", "timeRange": "today 5-y" }
```

Compare up to 5 terms on the same scale:

```json
{ "searchTerms": ["tea,coffee,matcha"], "isMultiple": true, "geo": "GB", "timeRange": "today 3-m" }
```

Compare **hundreds of terms** on one scale with an anchor term:

```json
{ "searchTerms": ["netflix", "hulu", "peacock", "paramount plus", "..."], "anchorTerm": "disney plus", "geo": "US" }
```

Each term is measured together with the anchor; `trendSummary[].averageVsAnchor` gives its popularity with the anchor = 100. Pick an anchor of similar popularity for the best precision.

Trending now:

```json
{ "mode": "trending", "trendingGeos": ["US", "GB", "IN"], "trendingHours": "24", "trendingMinVolume": 10000 }
```

You can also paste Google Trends links (`https://trends.google.com/trends/explore?q=bitcoin&geo=US&date=today%205-y`) — their region, dates, category and search type (web, YouTube, news, images, shopping) are used.

### Output example (classic format)

```json
{
  "searchTerm": "coffee",
  "geo": "US",
  "timeRange": "today 12-m",
  "interestOverTime_timelineData": [
    { "time": "1760832000", "formattedTime": "Oct 19 – 25, 2025", "value": [64], "hasData": [true], "formattedValue": ["64"] }
  ],
  "interestBySubregion": [{ "geoCode": "US-WY", "geoName": "Wyoming", "value": [100] }],
  "relatedQueries_top": [{ "query": "coffee near me", "value": 100, "formattedValue": "100" }],
  "relatedQueries_rising": [{ "query": "how to brew pour over coffee", "value": 3300, "formattedValue": "+3,300%" }],
  "trendSummary": [{ "term": "coffee", "average": 76.2, "peak": 100, "peakDate": "2026-04-12", "latest": 66, "changePercent": 6, "direction": "stable" }],
  "exploreUrl": "https://trends.google.com/trends/explore?q=coffee&date=today+12-m&geo=US"
}
```

Prefer spreadsheets? Set **Output format = Flat**: one row per date and term, per related query and per region — ready for Excel, Google Sheets or a BI tool.

### Use cases

- **SEO and content**: find rising queries and seasonal peaks before writing.
- **E-commerce and product research**: compare products, brands and categories over 5 years.
- **Market research and investing**: track interest in companies, assets and topics.
- **Newsrooms and social media**: monitor what is trending now in each country.
- **AI agents and dashboards**: schedule daily runs and feed the JSON into your pipeline.

### Pricing

- **$1.50 per 1,000 searches** (one search = one term or one group of compared terms, with all its data). Searches with no data are not charged.
- **$0.50 per 1,000 trending searches** in Trending now mode.

Cheaper on paid Apify plans.

### Good to know

- Values are Google's relative interest index (0–100), exactly as shown on Google Trends — not absolute search counts. Trending now gives Google's approximate search volume.
- Google sometimes shows unusual "rising" queries; they are returned as Google publishes them.
- Very rare terms get a low-volume warning: Google then shows data on only a few dates.
- Google Sheets import (`spreadsheetId`) is not supported; the field is accepted and ignored with a warning.
- Only public Google Trends data is collected.

### Related scrapers

Other ready-to-use Actors by RT Solutions:

- [Google News Scraper](https://apify.com/rt-solutions/google-news-scraper)
- [Google Ads Transparency Scraper](https://apify.com/rt-solutions/google-ads-transparency-scraper)
- [App Store Reviews Scraper with AI](https://apify.com/rt-solutions/appstore-reviews-ai)

# Actor input Schema

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

<b>Keywords</b>: analyse your search terms. <b>Trending now</b>: today's trending searches per country, with search volume and growth.

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

One term per line. Each line is one search. Tick <i>Multiple terms</i> to compare up to 5 terms on the same line, separated by commas (e.g. <code>tea,coffee,matcha</code>).

## `isMultiple` (type: `boolean`):

If checked, a comma separates terms compared together on the same scale (up to 5).

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

Ignored when a custom time range is set.

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

Format <code>YYYY-MM-DD YYYY-MM-DD</code>, e.g. <code>2024-01-01 2024-06-30</code>. Takes precedence over Time range.

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

Country to analyse. Worldwide gives interest by country.

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

Restrict to a Google Trends category.

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

Which Google search to measure.

## `includeCityData` (type: `boolean`):

Interest by city (single-term searches in a country) and by US metro area (DMA).

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

Same as the checkbox on Google Trends: also return regions and cities with little search volume (often many more cities, but small towns can then rank first).

## `anchorTerm` (type: `string`):

Optional. Each search is compared with this term, so that <b>hundreds of terms become comparable</b> on one scale: see <code>trendSummary.averageVsAnchor</code> (anchor = 100). Pick a stable, popular term, e.g. <code>weather</code>.

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

Classic keeps the official scraper's field names, so you can switch without changing your code.

## `startUrls` (type: `array`):

Paste Google Trends explore links, e.g. <code>https://trends.google.com/trends/explore?q=bitcoin\&geo=US</code>. Their own region, date, category and search type are used.

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

2-letter country codes, e.g. US, GB, IN, BR, DE, FR.

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

Time window for trending searches.

## `trendingActiveOnly` (type: `boolean`):

Keep only searches that are still trending now.

## `trendingMinVolume` (type: `integer`):

e.g. 10000 to keep only the big trends.

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

Maximum number of searches (or trending searches). 0 = no limit.

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

How many searches run at the same time (1–5).

## `maxRequestRetries` (type: `integer`):

Retries on a refused request, each with a new IP address.

## `viewedFrom` (type: `string`):

Only used when the residential network is needed.

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

Default Apify Proxy works; residential is used automatically only if needed.

## `spreadsheetId` (type: `string`):

Accepted for compatibility; ignored with a warning.

## `skipDebugScreen` (type: `boolean`):

Accepted for compatibility; ignored.

## `pageLoadTimeoutSecs` (type: `integer`):

Accepted for compatibility; ignored (no browser is used).

## `geoCode` (type: `string`):

Optional, overrides Region: any Google Trends code, e.g. US-CA, GB-ENG, FR-75.

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

Optional, overrides Time range: raw Google Trends format, e.g. today 2-y, now 7-d, 2024-01-01 2024-06-30, 2024-01-01T10 2024-01-02T10.

## `categoryId` (type: `integer`):

Optional, overrides Category: any Google Trends category or sub-category ID, e.g. 71 (Food & Drink).

## `tz` (type: `integer`):

Google Trends tz parameter (minutes behind UTC, e.g. 360 = UTC-6). Default 0 = UTC.

## `hl` (type: `string`):

Google Trends hl parameter, e.g. en-US, fr, de. Affects formatted dates and topic names.

## Actor input object example

```json
{
  "mode": "keywords",
  "searchTerms": [
    "web scraping"
  ],
  "isMultiple": false,
  "timeRange": "",
  "geo": "",
  "category": "",
  "property": "",
  "includeCityData": true,
  "includeLowVolumeRegions": false,
  "outputFormat": "classic",
  "trendingGeos": [
    "US"
  ],
  "trendingHours": "24",
  "trendingActiveOnly": false,
  "trendingMinVolume": 0,
  "maxItems": 0,
  "maxConcurrency": 3,
  "maxRequestRetries": 7,
  "viewedFrom": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "tz": 0,
  "hl": "en-US"
}
```

# Actor output Schema

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

All results.

# 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": [
        "web scraping"
    ],
    "trendingGeos": [
        "US"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rt-solutions/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": ["web scraping"],
    "trendingGeos": ["US"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rt-solutions/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": [
    "web scraping"
  ],
  "trendingGeos": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rt-solutions/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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