# Google Trends Scraper — Reliable, Cheap, No Blocks (`fabrikit/google-trends-scraper`) Actor

Google Trends Scraper that actually finishes: interest over time, interest by region, related queries and topics for up to 5 compared terms, plus the trending-now feed. Automatic proxy fallback and retry on rate limits. Pay per result, no subscription.

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

## Pricing

from $1.50 / 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?

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, Cheap, No Blocks

Pull **Google Trends** data as clean JSON: **interest over time**, **interest by region**, **related queries**, **related topics** and the **trending now** feed. Built around one goal: runs that actually finish. Google rate-limits Trends aggressively (HTTP 429); this Actor warms up a cookie session, paces requests, retries on fresh IPs and automatically climbs from datacenter to residential proxies when needed.

You pay per trend record saved, with compute and proxy included. See *How much does it cost* below.

### What you get

| Output | Record contains |
|---|---|
| `timeline` | ISO date, label, value (0-100), `isPartial` for every point, plus the average |
| `byRegion` | `geoCode`, `geoName`, `value` for each country / state / city / metro |
| `relatedQueries` | `query`, `value`, `formattedValue`, `type` (`top` or `rising`) |
| `relatedTopics` | `topic`, `topicType`, `value`, `formattedValue`, `type` (`top` or `rising`) — only returned when Google serves them (see FAQ) |
| `trendingNow` | search term, approximate traffic, publish time, headlines |

One record = one search term x one output. Empty outputs are skipped and never billed.

### Who it is for

- **SEO and content teams** checking seasonality and rising queries before planning articles or campaigns.
- **E-commerce and product managers** comparing demand for products, brands or features across countries and states.
- **Analysts and investors** who want Google search interest as a time series next to sales, prices or other signals.
- **Newsrooms and social media teams** watching what is trending right now in several countries.
- **Developers and AI agents** that need Trends data as JSON without maintaining their own anti-429 logic.

### Key features

- **Explore mode** for any list of terms: interest over time, interest by region, related queries and related topics.
- **Compare mode** (`compareTerms: true`): terms are grouped in batches of up to 5 and share one 0-100 scale, exactly like Google's compare view. With it off, each term gets its own scale.
- **Any geography**: worldwide, a country (`US`, `DE`, `BR`) or a sub-region (`US-CA`, `GB-ENG`). Region detail can be country, region/state, city or US metro area (`regionResolution`).
- **Any period**: past hour, 4 hours, day, 7 days, 30 days, 90 days, 12 months, 5 years, since 2004, or custom dates.
- **Five Google properties**: web, news, images, YouTube and Google Shopping search.
- **Trending now** for one or several countries, with approximate traffic and related news headlines.
- **Built for reliability**: cookie warm-up per session, jittered pacing, retries per widget and per group, and an automatic datacenter → residential proxy ladder that stays on the rung that works.
- **Clear failures**: invalid input (bad geo, missing custom dates) fails immediately with a readable message, and a run that collects nothing fails instead of returning silent empties. A `SUMMARY` record in the key-value store lists empty outputs skipped, the proxy rung used and any failed groups.

### Input

```json
{
  "searchTerms": ["bitcoin", "ethereum"],
  "compareTerms": false,
  "geo": "US",
  "timeRange": "today 12-m",
  "property": "web",
  "outputs": ["timeline", "byRegion", "relatedQueries"],
  "maxItems": 50
}
```

- **searchTerms** - any number of terms. With `compareTerms: true` they are grouped in batches of 5 and share one 0-100 scale; otherwise each term is analysed on its own.
- **geo** - `US`, `DE`, `BR`... or a sub-region such as `US-CA`; empty = worldwide.
- **timeRange** - `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m`, `today 5-y`, `all`, or `custom` with `dateFrom` / `dateTo` (YYYY-MM-DD).
- **category** - Google Trends category id (0 = all).
- **property** - `web`, `news`, `images`, `youtube`, `shopping`.
- **language** - interface language (`en-US`, `es`, `de`...); affects labels and the language of related queries.
- **regionResolution** - `AUTO`, `COUNTRY`, `REGION`, `CITY` or `DMA` (US metro areas).
- **mode** - `explore` or `trendingNow` (set `trendingGeos`, e.g. `["US","GB"]`).
- **maxItems** - stop after this many records (term x output).
- **maxConcurrency** - parallel request groups (1-5, default 2). Keep it low for reliability.
- **proxyConfiguration** - default is Apify datacenter with automatic RESIDENTIAL fallback.

#### More input examples

Compare two products over 12 months on one scale (the "Compare search interest over 12 months" example task):

```json
{
  "mode": "explore",
  "searchTerms": ["electric car", "hybrid car"],
  "compareTerms": true,
  "timeRange": "today 12-m",
  "outputs": ["timeline", "byRegion", "relatedQueries"]
}
```

Interest by state in Brazil over the last 90 days:

```json
{
  "mode": "explore",
  "searchTerms": ["futebol"],
  "geo": "BR",
  "timeRange": "today 3-m",
  "regionResolution": "REGION",
  "outputs": ["timeline", "byRegion", "relatedQueries"]
}
```

What the US and UK are searching right now:

```json
{ "mode": "trendingNow", "trendingGeos": ["US", "GB"], "maxItems": 50 }
```

### Output example

```json
{
  "type": "timeline",
  "searchTerm": "bitcoin",
  "geo": "WORLDWIDE",
  "timeRange": "today 12-m",
  "property": "web",
  "averageValue": 43.1,
  "points": [
    { "date": "2025-10-12T00:00:00.000Z", "label": "Oct 12 – 18, 2025", "value": 62, "isPartial": false }
  ]
}
```

```json
{
  "type": "relatedQueries",
  "searchTerm": "bitcoin",
  "related": [
    { "type": "top", "query": "bitcoin price", "value": 100, "formattedValue": "100" },
    { "type": "rising", "query": "bitcoin etf", "value": 250, "formattedValue": "+250%" }
  ]
}
```

#### Output fields

| Field | In record types | Description |
|---|---|---|
| `id` | all | Stable key: type, term, geo, time range, property and category. |
| `type` | all | `timeline`, `byRegion`, `relatedQueries`, `relatedTopics` or `trendingNow`. |
| `searchTerm` | all | The term (or the trending search). |
| `comparedWith` | explore | Other terms in the same compare group, or `null`. |
| `geo` | all | Country / region code, or `WORLDWIDE`. |
| `timeRange`, `category`, `property` | explore | The settings used for the request. |
| `averageValue` | timeline | Average of the complete (non-partial) points. |
| `points` | timeline | `date`, `label`, `value` (0-100), `isPartial`. |
| `regionLevel` | byRegion | Requested region detail. |
| `regions` | byRegion | `geoCode`, `geoName`, `value`, sorted from highest; regions with no data are left out. |
| `related` | relatedQueries / relatedTopics | Top and rising entries with `value` and `formattedValue` (e.g. `+250%`, `Breakout`). |
| `rank` | trendingNow | Position in the country's feed. |
| `approxTraffic`, `approxTrafficMin` | trendingNow | Google's traffic label (e.g. `200K+`) and its numeric lower bound. |
| `publishedAt` | trendingNow | When the trend was published. |
| `newsItems` | trendingNow | Related headlines: `title`, `url`, `source`. |
| `pictureUrl` | trendingNow | Image Google shows for the trend. |
| `scrapedAt` | all | When the record was collected. |

### How much does it cost to scrape Google Trends?

| Event | When it is charged |
|---|---|
| `trend-result` | One term x one output, or one trending search |
| Actor start | Once per run (a fraction of a cent) |

From 30 October 2026, 1,000 trend records cost US$4 on the Apify Free plan; paid Apify plans pay less per record — see the **Pricing** tab for your plan's rate. Compute and residential proxy are included in the event price, and empty outputs are never billed.

Example: 10 terms x 3 outputs (timeline, byRegion, relatedQueries) = at most 30 records.

### FAQ

**Why does it stay reliable?** Cookie warm-up per session, jittered pacing, widget-level retries, whole-group retries on a fresh session and IP, and an automatic datacenter -> residential ladder that remembers the rung that works. If Google still refuses, the run fails with a clear message instead of returning silent empties.

**Why are related topics sometimes missing?** Google currently returns empty topic lists to automated clients for many queries. Those outputs are skipped and not billed. Related queries are unaffected.

**Are values absolute search counts?** No. Google Trends gives relative interest (0-100); that is how the source works.

**Trending now size?** Google's public feed lists about 10 current searches per country; use several `trendingGeos`.

**Can I compare more than 5 terms on one scale?** Google compares at most 5 terms per request. With `compareTerms: true` the actor makes groups of 5; values are comparable inside each group but not across groups. A common trick is to include one anchor term in every group.

**Why do my numbers differ slightly from the Google Trends website?** Google samples searches, so the same query can return slightly different values on different days or from different sessions. The most recent point is often marked `isPartial: true` because the period is not complete yet.

**How do I get daily data for a whole year?** Google picks the granularity from the period: daily up to about 9 months, weekly for 12 months and 5 years, monthly for longer ranges. For daily points over a year, run several `custom` date ranges.

**Can I run it every day?** Yes. Save your input as a task and schedule it; each run produces a fresh dataset you can append to a spreadsheet or database through an integration.

### Use cases

SEO and keyword research, seasonality analysis, content planning, market and product research, news monitoring, regional demand comparison.

### Is it legal to scrape Google Trends?

Google Trends shows aggregated, anonymised search interest to any visitor, and this actor only collects what is publicly visible on Google Trends without logging in. It does not collect data about individual users. Trending-now records can include news headlines and links, which belong to their publishers. You are responsible for using the data lawfully, including data-protection laws such as the EU GDPR, Chile's Ley 21.719 or the California CCPA if you combine it with personal data, and for respecting Google's terms of service. This is general information, not legal advice.

### Integrations

Call the Google Trends Scraper through the Apify API or the JavaScript and Python clients, react to finished runs with webhooks, or schedule it in Apify Console for daily or weekly snapshots. It connects to n8n, Make and Zapier, and to LangChain and LlamaIndex through their Apify integrations. AI agents in Claude, ChatGPT, Cursor and other MCP clients can find and run it through Apify's MCP server. Export results as JSON, CSV or Excel, or read them from the dataset API.

### Use with AI agents

Use this actor when you need Google Trends data: relative search interest over time or by region, related and rising queries for one or more terms, or what a country is searching right now.

```json
{ "searchTerms": ["solar panels"], "geo": "US", "timeRange": "today 12-m", "outputs": ["timeline", "relatedQueries"] }
```

Main output fields: `type`, `searchTerm`, `geo`, `points` (date, value 0-100), `averageValue`, `regions`, `related` (top and rising queries), and for trending searches `rank`, `approxTraffic`, `newsItems`. It is pay-per-event: an agent pays a small start fee plus a fixed price per record saved, not for compute time.

### Related actors

- [Google News Scraper](https://apify.com/fabrikit/google-news-scraper) — the articles behind a spike in search interest.
- [YouTube Scraper](https://apify.com/fabrikit/youtube-videos-scraper) — videos and channels for a trending topic.
- [Google Maps Scraper](https://apify.com/fabrikit/google-maps-places-scraper) — businesses in the places where interest is highest.
- [Google Ads Transparency Scraper](https://apify.com/fabrikit/google-ads-transparency-scraper) — which advertisers are bidding on a topic.

#### Ready-made examples

- [Trending searches in the US right now](https://apify.com/fabrikit/google-trends-scraper/examples/trending-searches-us)
- [Compare search interest over 12 months](https://apify.com/fabrikit/google-trends-scraper/examples/compare-search-interest-12-months)
- [Search interest by state in Brazil](https://apify.com/fabrikit/google-trends-scraper/examples/brazil-interest-by-state)

### Changelog

- **2026-10-16** — README expanded: more input examples, output field table, FAQ, legal notes, integrations and example tasks.
- **2026-10-15** — Build 0.1.4: README included in the build; published on the Apify Store. Tiered pricing announced, effective 2026-10-30 (lower per-record price on paid Apify plans).
- **2026-10-13** — Builds 0.1.1–0.1.3: initial release (explore and trending-now modes); more retries per widget and per group after a failed compare test; default memory 512 MB.

### En español

Extrae datos de **Google Trends** en JSON: interés en el tiempo, por región, consultas y temas relacionados y tendencias del momento. Reintentos automáticos, calentamiento de cookies y cambio automático de proxy datacenter a residencial para evitar bloqueos 429. Se cobra por registro guardado; el precio vigente para tu plan está en la pestaña Pricing.

# Actor input Schema

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

`explore` = interest over time / regions / related searches for your terms. `trendingNow` = what people are searching right now in a country.

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

Terms or topics to look up (explore mode).

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

On: up to 5 terms are compared on the same 0-100 scale (like Google's compare view). Off: every term is looked up on its own scale.

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

ISO country code (`US`, `DE`, `BR`) or sub-region (`US-CA`, `GB-ENG`). Empty = worldwide.

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

Interface language (hl), e.g. `en-US`, `es`, `de`. Affects labels and related-query language.

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

Period to analyse. `custom` uses the two dates below.

## `dateFrom` (type: `string`):

YYYY-MM-DD. Only used when Time range is `custom`.

## `dateTo` (type: `string`):

YYYY-MM-DD. Only used when Time range is `custom`.

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

Google Trends category number (0 = all categories, 7 = Finance, 3 = Arts & Entertainment, 45 = Health, 5 = Computers & Electronics, 71 = Food & Drink).

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

Which Google search the trend refers to.

## `outputs` (type: `array`):

Which datasets to return per term. Each term x output = one billed record (empty outputs are skipped and not billed). Related topics are returned only when Google serves them for the query.

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

Granularity of interest by region. Auto = Google's default for the chosen geo (countries worldwide, states/regions inside a country).

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

Country codes (or US states) for trendingNow mode, e.g. `US`, `GB`, `BR`.

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

Stop after this many records (term x output).

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

Concurrent request groups, each with its own session and pacing. Keep low for reliability.

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

Default: Apify datacenter proxy with automatic fallback to RESIDENTIAL when Google rate-limits (429). Pick RESIDENTIAL groups to start there.

## Actor input object example

```json
{
  "mode": "explore",
  "searchTerms": [
    "bitcoin",
    "ethereum"
  ],
  "compareTerms": false,
  "geo": "",
  "language": "en-US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "outputs": [
    "timeline",
    "byRegion",
    "relatedQueries"
  ],
  "regionResolution": "AUTO",
  "trendingGeos": [
    "US"
  ],
  "maxItems": 50,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One record per term and output type (timeline, byRegion, relatedQueries, relatedTopics) or per trending search

# 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"
    ],
    "geo": "",
    "outputs": [
        "timeline",
        "byRegion",
        "relatedQueries"
    ],
    "trendingGeos": [
        "US"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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": [
        "bitcoin",
        "ethereum",
    ],
    "geo": "",
    "outputs": [
        "timeline",
        "byRegion",
        "relatedQueries",
    ],
    "trendingGeos": ["US"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/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": [
    "bitcoin",
    "ethereum"
  ],
  "geo": "",
  "outputs": [
    "timeline",
    "byRegion",
    "relatedQueries"
  ],
  "trendingGeos": [
    "US"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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