# Google Trends Scraper (`bigochelo/google-trends-scraper`) Actor

Google Trends API without an API key: get interest over time, interest by region, related queries and related topics for any keyword, country and period, plus a ready-made trend summary (rising/stable/falling). Retries and proxy rotation built in; failed searches are not charged.

- **URL**: https://apify.com/bigochelo/google-trends-scraper.md
- **Developed by:** [Marcelo Palacios](https://apify.com/bigochelo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 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 Google Trends API

Get **Google Trends data you can rely on**: interest over time, interest by region, related queries and related topics for any keyword, country and time range. Every result also includes a **plain-language trend summary** (average, peak, latest value and whether the term is rising, stable or falling), so you can use the data straight away in reports, spreadsheets or AI agents.

Google Trends rate-limits automated requests aggressively. This Actor is built around that problem: it rotates residential proxy sessions, backs off automatically and retries each request up to 8 times, so your runs finish instead of failing. **Searches that still fail are never charged.**

### Quick reference for AI agents and developers

- **Minimal input:** `{"searchTerms": ["padel"], "geo": "US", "timeRange": "today 12-m"}`
- **Quick answer:** read `summary[term].trend` (`rising` / `stable` / `falling`), plus `average`, `peak`, `peakDate`, `latest` and `changePercent`.
- **Details:** `interestOverTime` (0-100 timeline), `interestByRegion`, `relatedQueries[term].rising` (new keyword ideas; "Breakout" = more than +5000%).
- **Compare terms:** set `"compareTerms": true` to get values relative to each other (up to 5 per group).
- **Errors:** searches that still fail after all retries produce no dataset item and are **not charged**. They are listed in the `RUN_SUMMARY` key-value record.

### What you can extract

| Data | What it tells you |
| --- | --- |
| Interest over time | Search interest (0-100) for every day, week or month of the period |
| Trend summary | Average, peak and peak date, latest value, % change and direction (rising / stable / falling) |
| Interest by region | Where the term is most popular: countries, subregions, cities or US metro areas |
| Related queries | Top and rising searches, including "Breakout" terms growing more than 5,000% |
| Related topics | Top and rising topics connected to your keyword |

You can analyse **web, image, news, YouTube or Google Shopping** searches, narrow results with a category, and compare up to 5 terms against each other.

### Use cases

- **SEO and content:** find rising queries before your competitors and plan content around them.
- **Product research and e-commerce:** check whether demand for a product is growing, seasonal or fading.
- **Market and investment research:** track interest in brands, products or topics over time and by region.
- **AI agents and automation:** feed clean JSON with a ready-made trend summary into your workflows, n8n, Make, Zapier or an MCP client.

### How to use it

1. Add one or more **search terms**.
2. Optionally choose a **country** (US, GB, ES, DE...), a **time range** and the **search type**.
3. Turn on **Compare terms** if you want terms measured on the same scale, like typing them side by side on Google Trends.
4. Click **Start** and download the results as JSON, CSV, Excel or via API.

#### Input example

```json
{
  "searchTerms": ["padel", "pickleball"],
  "geo": "US",
  "timeRange": "today 12-m",
  "compareTerms": true
}
```

### Output example

One result per search term (or per group of compared terms):

```json
{
  "searchTerms": ["padel"],
  "geo": "ES",
  "timeRange": "today 12-m",
  "category": 0,
  "searchType": "web",
  "summary": {
    "padel": {
      "average": 84.5,
      "peak": 100,
      "peakDate": "2025-11-09T00:00:00Z",
      "latest": 100,
      "changePercent": 29.9,
      "trend": "rising"
    }
  },
  "interestOverTime": [
    { "date": "2025-10-19T00:00:00Z", "timestamp": 1760832000, "formattedTime": "Oct 19 – 25, 2025", "values": { "padel": 77 }, "isPartial": false }
  ],
  "interestByRegion": [
    { "geoCode": "ES-IB", "geoName": "Balearic Islands", "values": { "padel": 100 } }
  ],
  "relatedQueries": {
    "padel": {
      "top": [ { "query": "padel premier", "value": 100, "formattedValue": "100", "link": "https://trends.google.com/trends/explore?q=padel+premier&date=today+12-m&geo=ES" } ],
      "rising": [ { "query": "premier padel 2026", "value": 7950, "formattedValue": "Breakout" } ]
    }
  },
  "relatedTopics": { "padel": { "top": [], "rising": [] } },
  "scrapedAt": "2026-10-24T13:30:00Z"
}
```

### Pricing

You pay a small fee per run plus a fee per result (one result = one search term, or one group of compared terms, with all the sections you selected). You never pay for searches that fail. See the pricing tab for current prices.

### FAQ

**What do the 0-100 values mean?**
Google Trends shows relative interest, not search volume: 100 is the peak popularity of the term in the chosen place and period, 50 is half as popular, and 0 means there was not enough data.

**Why do compared terms have different numbers than single terms?**
When you compare terms, they share one scale, so the most popular term sets the 100. Each single term is scaled on its own.

**Do I need my own proxies?**
No. Apify residential proxies are selected by default because Google Trends blocks most datacenter IPs.

**Something did not work?**
Open an issue on the Issues tab with the input you used and we will look at it quickly.

This Actor collects publicly available, aggregated and anonymous Google Trends data. It does not collect any personal data. It is not affiliated with or endorsed by Google.

***

If this Actor saves you time, a short review on the Store page helps other people find it. Something not working? Open an issue and it will be fixed.

# Actor input Schema

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

Keywords to look up, one per line. Example: \["padel", "pickleball"]. Each term is fetched separately unless 'compareTerms' is on.

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

If on, terms are compared together in groups of up to 5 (like typing them side by side on Google Trends), so values are relative to each other. If off, each term gets its own result with its own 0-100 scale.

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

Two-letter country code (US, GB, ES, DE...) or region code (US-CA, ES-MD). Empty = worldwide. Example: "US".

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

Period to analyse, e.g. "now 7-d" (last 7 days), "today 12-m" (last 12 months), "today 5-y". Ignored if 'customTimeRange' is set.

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

Optional. Start and end date separated by a space, for example: 2024-01-01 2024-12-31

## `searchType` (type: `string`):

Which Google search to measure: web (default), images, news, youtube or shopping.

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

Optional Google Trends category ID to narrow the meaning of a term (0 = all categories). Example: 71 = Food & Drink, 7 = Finance.

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

Timeline of search interest (0-100) plus a summary with average, peak, latest value and trend direction.

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

Where the term is most popular.

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

Top and rising related searches (rising ones show growth %, or 'Breakout'). Useful for finding new keyword ideas.

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

Top and rising related topics.

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

Level of detail for 'Interest by region'. Automatic = countries for worldwide, subregions inside a country.

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

Also return regions with little search volume.

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

Language for region and topic names, e.g. en-US, es, de, fr.

## `maxRetries` (type: `integer`):

How many times to retry with a fresh proxy session when Google rate-limits a request.

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

Google Trends blocks most datacenter IPs. Residential proxies give the most reliable results.

## Actor input object example

```json
{
  "searchTerms": [
    "padel",
    "pickleball"
  ],
  "compareTerms": false,
  "geo": "",
  "timeRange": "today 12-m",
  "searchType": "web",
  "category": 0,
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeRelatedQueries": true,
  "includeRelatedTopics": true,
  "regionResolution": "",
  "includeLowVolumeRegions": false,
  "language": "en-US",
  "maxRetries": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (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": [
        "padel",
        "pickleball"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigochelo/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": [
        "padel",
        "pickleball",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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