# Google Trends API & Scraper: Regions, Related Queries & Topics (`clean-fetch/google-trends-scraper`) Actor

Returns real related topics where other Google Trends scrapers return empty lists. Trend line, regions (states, metros, cities), related queries and topics for thousands of keywords in one run. Buy all four or just one, from $0.50 per 1,000. Pay only for data delivered.

- **URL**: https://apify.com/clean-fetch/google-trends-scraper.md
- **Developed by:** [CleanFetch](https://apify.com/clean-fetch) (community)
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 10 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 related queries

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 API & Scraper: Regions, Related Queries & Topics

**The Google Trends scraper that actually returns related topics.** Get the complete Google Trends picture for whole keyword lists in one run: **interest over time, interest by region (states, metro areas, cities), related queries and related topics**, for every keyword.

- ✅ **Real related topics**, where other scrapers hand you empty lists
- ✅ **All four parts in one run**, for thousands of keywords at once
- ✅ **Buy only the parts you need**: all four together, or any one on its own (e.g. related topics only)
- ✅ **Complete data for a fraction of what others charge**, and you pay only for data delivered
- ✅ **No proxies, no setup, no usage fees:** everything is included

### 💰 Pricing

Every price is **per 1,000 keywords**, and you're charged only for the parts actually delivered.

| Preset | You get | Price per 1,000 |
|---|---|---|
| Trend line | Interest over time | **$1.50** |
| Market | + interest by region | **$2.00** |
| Research | + related queries | **$2.50** |
| ⭐ **Complete** (default) | + **related topics**: all four parts | **$4.00** |
| Complete + local detail | Complete, plus **metro areas** (US) and **cities** | **$5.00** |
| 🧩 **Custom** | **Only the parts you pick**, alone or together | Add up the parts below |

**Need just one part?** Pick **Custom** and choose only what you need. Each part is priced on its own, per 1,000 keywords:

| Part | Price per 1,000 |
|---|---|
| Trend line (interest over time) | $1.50 |
| Regions (each breakdown: states, metro areas or cities) | $0.50 |
| Related queries | $0.50 |
| Related topics | $1.50 |

For example, **related topics only: $1.50 per 1,000**. **Related queries only: $0.50 per 1,000**. Low-volume keywords are still verified and free.

Scrapers that reliably deliver all four parts charge **many times more** for the same data. Here, complete data with real related topics costs **$4.00 per 1,000**, and every preset is priced to compete.

**Example:** 1,000 keywords on Complete cost **$4.00**. If 30 of them have too little search volume for Google to publish data, those 30 are free and you pay **$3.88**.

**You never pay for:**

- a part Google didn't deliver;
- a keyword with too little search volume (verified, free);
- a keyword that failed, or an input line that couldn't be used;
- proxies or compute: no usage fees on top.

*Optional add-on: spreadsheet rows (one row per data point, for CSV, Excel, Sheets and BI tools) add $0.01 per 1,000 rows. The default output has no extra cost.*

### 🏆 Why it beats other Google Trends scrapers

We tested **every major Google Trends scraper on the Apify Store**. Here's what we found, and what this one does instead:

| | **Other Google Trends scrapers** | **This scraper** |
|---|---|---|
| **Related topics** | Most don't deliver them: they leave them out or return **empty lists**, usually **without telling you**, and some still charge for them | ✅ **Real related topics** for every keyword Google has data for |
| **All four parts** | Most can't deliver all four; others need **separate runs** for each part | ✅ **All four in one run** |
| **Buying only what you need** | **Fixed bundles**: you get, and pay for, whatever they return, whether you need it or not | ✅ **Pick any part on its own** or any mix, and pay only for those |
| **Price for complete data** | **$33 to $820+** per 1,000 among those that deliver it, often **plus usage fees** | ✅ **$4.00**, everything included |
| **Missing data** | Silently dropped: you can't tell "no data" from "failed" | ✅ A **status and a plain-language note** on every result and every part |
| **Metro areas and cities** | Rare, and incomplete in our tests | ✅ All 210 US metro areas, plus cities |
| **Big lists** | Small batch limits, or failed runs on Google's rate limits | ✅ Up to 5,000 lookups per run; rate limits handled for you |

### 📦 What you get for each keyword

| Part | What it is |
|---|---|
| **Trend line** (in every preset; optional in Custom) | Google's 0–100 interest over time (hourly, daily, weekly or monthly), plus average, peak, latest value and trend direction |
| **Regions** | Interest by state or region (countries when worldwide); with local detail also **metro areas** (US) and **cities** |
| **Related queries** | The top 25 and rising searches, with growth such as "+250%" or "Breakout" |
| **Related topics** | The top and rising topics: entities such as "Air fryer: Cooking appliance" |

Every keyword also comes with **summary numbers** (average, peak, latest, trend, top region, top query, top topic) and **counts** showing how much data it holds.

### 🎯 Use cases

- **SEO and content:** find rising queries and topics to write about before they peak.
- **Keyword research:** score thousands of keywords at once and prune the ones nobody searches for.
- **Market research:** compare interest across countries, states, metro areas and cities.
- **E-commerce:** time launches and stock to seasonal demand.
- **Investing and finance:** track interest in companies, products and themes over time.
- **AI agents and dashboards:** feed clean, structured Trends data into your pipelines.

### 🚀 How to use it

1. **Add your keywords**, one per line.
2. **Pick a preset**, a location (`US`, `GB`, `US-CA`, or empty for worldwide) and a time range.
3. **Click Start.** Results appear as they finish: view them as a table, or download JSON, CSV or Excel.

Add several locations or time ranges, and every keyword runs in each.

### ✅ Every result has a status

| Status | Meaning | Charged |
|---|---|---|
| `complete` | Every requested part is delivered, or verified as not published by Google (e.g. no related topics for a niche term) | Delivered parts only |
| `low_volume` | Google publishes no data for the term in that location and time range (verified). Any faint signal is included | **Free** |
| `partial` | One part is missing; the note names it first and says the others are delivered | Delivered parts only |
| `invalid_input` | The location, dates or keyword can't be used; the note says why | Free |
| `failed` | No data could be fetched for this keyword this time | Free |

**"Low volume" is an answer, not an error.** Google only publishes Trends data when enough people search for a term. A low-volume result tells you the term is niche, emerging or seasonal. That's useful for pruning lists or spotting early niches.

### ⌨️ Input examples

**Simple:**

```json
{ "keywords": ["air fryer", "pickleball", "ai agents"] }
```

**Several locations and time ranges** (every keyword runs in each):

```json
{ "keywords": ["air fryer"], "geos": ["US", "GB", "DE"], "timeRanges": ["today 12-m", "today 5-y"], "preset": "research" }
```

**Only the parts you need** (here related topics alone, $1.50 per 1,000):

```json
{ "keywords": ["air fryer", "pickleball"], "preset": "custom", "components": ["relatedTopics"] }
```

**Complete + local detail** (states, metro areas and cities):

```json
{ "keywords": ["coffee"], "geo": "US", "preset": "local" }
```

**From Google Trends links:**

```json
{ "startUrls": [{ "url": "https://trends.google.com/trends/explore?q=coffee&geo=GB&date=today%205-y" }] }
```

**More options:** search type (web, images, news, YouTube, Google Shopping), category (e.g. 71 = Food & Drink), exact dates (`"customTimeRange": "2024-01-01 2024-06-30"`), language, and a maximum number of lookups. Up to **5,000 lookups** (keyword × location × time range) per run.

### 📄 Output

**One item per keyword** (default), abridged:

```json
{
  "keyword": "air fryer", "location": "US", "timeRangeLabel": "Past 12 months", "status": "complete",
  "statusMessage": "All 4 requested parts delivered.",
  "trendPoints": 53, "regionsCount": 51, "topQueriesCount": 25, "risingQueriesCount": 25, "topTopicsCount": 20, "risingTopicsCount": 12,
  "averageInterest": 66.0, "peakInterest": 100, "peakDate": "2026-04-12", "latestInterest": 57,
  "trend": "falling", "trendChangePct": -14.3, "topRegion": "Wyoming", "topQuery": "air fryer chicken",
  "topRisingQuery": "best air fryer 2026 (Breakout)", "topTopic": "air fryer",
  "interestOverTime": [{ "date": "2025-10-19T00:00:00Z", "label": "Oct 19 – 25, 2025", "value": 54, "hasData": true, "isPartial": false }],
  "interestByRegion": [{ "name": "Wyoming", "code": "US-WY", "value": 100, "hasData": true }],
  "relatedQueries": { "top": [{ "query": "air fryer chicken", "value": 100 }], "rising": [{ "query": "best air fryer 2026", "growth": "Breakout" }] },
  "relatedTopics": { "top": [{ "title": "air fryer", "type": "Topic", "value": 100 }], "rising": [] },
  "charged": { "trend-line": 1, "regions": 1, "related-queries": 1, "related-topics": 1 },
  "googleTrendsUrl": "https://trends.google.com/trends/explore?q=air+fryer&date=today+12-m&hl=en-US&geo=US"
}
```

**Table views in the Console:**

- **Overview:** one row per keyword with its result, how much data it holds and the headline numbers.
- **Full data:** every point, region, query and topic.
- **Billing:** every part's status and exactly what was charged.
- **Spreadsheet rows:** for the spreadsheet-rows output, one row per data point.

**Spreadsheet rows** (`"outputFormat": "spreadsheetRows"`) give one row per data point (`rowType`: `summary`, `interestOverTime`, `region`, `relatedQuery`, `relatedTopic`), ready to filter and pivot in Sheets, Excel or BI tools. Every row has the same columns (`item`, `group`, `rank`, `value`, `growth`, `status`), and they show in the **Spreadsheet rows** tab.

### 🔌 Integrations

Use it from the **Apify API**, the **Python** and **JavaScript** clients, or no-code tools such as **Make, Zapier and n8n**. Send results to **Google Sheets**, Slack or your own systems with webhooks, or use it with AI agents through the **Apify MCP server**. Schedule it to track keywords daily or weekly.

### ❓ FAQ

**Is there an official Google Trends API?**
Not one you can simply sign up for: Google's own API is a limited, invitation-only alpha. This scraper gives you the same data as the Google Trends website, as structured JSON, CSV or Excel, through Apify's API.

**Do I need my own proxies?**
No. Everything needed to reach Google Trends reliably is included in the price.

**Why are some keywords "low volume"?**
Google only publishes Trends data for terms enough people search for. Those keywords are verified and **free**. For a wider view, try a bigger location (worldwide) or a longer time range (past 5 years).

**Are the values comparable between keywords?**
Each keyword is scaled 0–100 within its own location and time range, exactly as on Google Trends. Comparing several terms on one shared scale is coming soon.

**I use Apify's Google Trends Scraper. Can I switch?**
Yes: paste your existing input. `searchTerms`, `geo`, `timeRange`, `category`, `customTimeRange`, `startUrls`, `isMultiple` and `maxItems` work as they are.

**Is it legal to scrape Google Trends?**
This scraper collects publicly available data that anyone can see on the Google Trends website. You're responsible for how you use the data, in line with the laws that apply to you and Google's terms.

**A question, or a keyword that looks wrong?** Open an issue on the Issues tab with the run link; we aim to reply within 24 hours.

# Actor input Schema

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

One keyword per line. Each keyword gets its own result on its own 0–100 scale. Up to 5,000 keyword × location × time range lookups per run.

## `preset` (type: `string`):

Pick the data you need. Prices are per 1,000 keywords, and you pay only for the parts actually delivered: a part Google doesn't deliver, and a keyword with too little search volume (verified), are free.

## `components` (type: `array`):

Used only when "What to get" is Custom (ignored by every other preset). Pick one or more parts, alone or together, and pay only for those. Per 1,000 keywords: trend line $1.50, regions $0.50, related queries $0.50, related topics $1.50.

## `regionResolutions` (type: `array`):

Which breakdowns of interest by region to get, for Custom. Each one delivered counts as one regions part ($0.50 per 1,000). Metro areas (DMA) exist for the United States only.

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

Country code (US, GB, IN), a region (US-CA), or leave empty for worldwide.

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

Run every keyword in each of these locations (same codes as Location). Overrides Location.

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

The period to look at. Shorter ranges give finer points (hourly or daily); longer ranges give weekly or monthly points.

## `timeRanges` (type: `array`):

Run every keyword for each of these time ranges: codes such as "today 12-m", "today 5-y", "now 7-d", or dates as "YYYY-MM-DD YYYY-MM-DD". Overrides Time range.

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

Exact dates as YYYY-MM-DD YYYY-MM-DD, from 2004-01-01 on. Overrides both time range fields.

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

Which Google search the interest is measured on: web, images, news, YouTube or Google Shopping.

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

Google Trends category id, as in the "cat=" part of a Trends link. 0 = all categories. Examples: 71 Food & Drink, 7 Finance, 45 Health.

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

Paste trends.google.com/trends/explore links: their keywords, location, dates, category and search type are used as they are.

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

One item per keyword (nested; best for JSON and APIs, no extra cost), or spreadsheet rows with one row per data point (best for CSV, Excel, Google Sheets and BI tools; adds $0.01 per 1,000 rows). Spreadsheet rows show in the Output's "Spreadsheet rows" tab.

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

Language for labels, region names and related results, e.g. en-US, de, fr, ja, pt-BR.

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

Stop after this many keyword × location × time range lookups. Leave empty to process all.

## `maxTopicsWaitMinutes` (type: `integer`):

Google releases related topics at a limited pace, so keywords wait their turn while the run continues. Once everything else is fetched, the run keeps waiting up to this long for the last ones; any still withheld are saved without related topics, which are not charged. 0 = don't wait at the end.

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

Same as Keywords. Lets you paste an input made for Apify's Google Trends Scraper without changes.

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

As in Apify's Google Trends Scraper: split each search term at commas. Each term gets its own result; comparing terms on one scale arrives in v1.1.

## Actor input object example

```json
{
  "keywords": [
    "air fryer",
    "pickleball",
    "ai agents"
  ],
  "preset": "complete",
  "geo": "US",
  "timeRange": "today 12-m",
  "property": "web",
  "category": 0,
  "outputFormat": "perKeyword",
  "language": "en-US",
  "maxTopicsWaitMinutes": 15
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per keyword: its status, how much data it holds and the headline numbers.

## `fullData` (type: `string`):

Every trend point, region, related query and related topic for each keyword.

## `billing` (type: `string`):

Every part's status and exactly what was charged for each keyword.

## `spreadsheetRows` (type: `string`):

With the spreadsheet-rows output: one row per data point, with the same columns on every row.

## `allItems` (type: `string`):

Every dataset item as written: one per keyword, or one per data point with the spreadsheet-rows output.

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

Counts by status, timing and charges for the whole run.

# 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": [
        "air fryer",
        "pickleball",
        "ai agents"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clean-fetch/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 = { "keywords": [
        "air fryer",
        "pickleball",
        "ai agents",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("clean-fetch/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 '{
  "keywords": [
    "air fryer",
    "pickleball",
    "ai agents"
  ]
}' |
apify call clean-fetch/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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