# Google Trends Bulk Extractor (`prodbysky/google-trends-bulk-extractor`) Actor

Bulk-extract Google Trends data for one or many keywords. Returns interest over time, interest by region, related queries, and related topics in a single run. No rate-limit games required.

- **URL**: https://apify.com/prodbysky/google-trends-bulk-extractor.md
- **Developed by:** [sky](https://apify.com/prodbysky) (community)
- **Categories:** SEO tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Trends Bulk Extractor

Apify Actor that bulk-extracts Google Trends data for one or many keywords in
a single run. Returns interest over time, interest by region, related
queries, and (optionally) related topics, structured per keyword batch.

### Why this actor

Google Trends has no public API. The unofficial `google-trends-api` npm
package wraps Trends' internal AJAX endpoints and is the same approach most
free tools use. Running it through Apify means you don't have to manage the
proxy rotation, the manual URL-tweaking, or the slow per-keyword web UI —
give it a keyword list, get back structured data.

### Input

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `keywords` | string[] | _required_ | 1-5 keywords per request (Trends limit). |
| `geo` | string | `""` | Two-letter country code, empty = worldwide. |
| `timeRange` | string | `"today 12-m"` | Trends timeframe string (e.g. `today 5-y`, `now 7-d`) or custom range. |
| `category` | integer | `0` | Trends category ID; 0 = all. |
| `includeInterestOverTime` | boolean | `true` | |
| `includeInterestByRegion` | boolean | `true` | |
| `includeRelatedQueries` | boolean | `true` | |
| `includeRelatedTopics` | boolean | `false` | |
| `maxRelatedItems` | integer | `25` | Cap returned related queries/topics per rank. |

If you give more than 5 keywords, the Actor automatically batches them into
groups of 5 (each batch = one result item).

### Output

Each dataset item represents one batch:

```json
{
  "keywords": ["electric scooter", "e-bike"],
  "geo": "US",
  "timeframe": "today 3-m",
  "category": 0,
  "fetchedAt": "2026-07-04T20:30:00.000Z",
  "interestOverTime": { "default": { "timelineData": [...] } },
  "interestByRegion": { "default": { "geoMapData": [...] } },
  "relatedQueries": {
    "top":     [ { "query": "...", "value": 100, "link": "..." }, ... ],
    "rising":  [ { "query": "...", "value": 5000, "link": "..." }, ... ],
    "sourceShape": "rankedList",
    "default":  { ...raw upstream payload... }
  }
}
````

`relatedQueries` and `relatedTopics` use a normalised `{ top, rising, sourceShape, default }`
shape. The `sourceShape` field tells you which upstream shape the response was
detected as — `"rankedList"` is the current google-trends-api shape (which
itself is normalised through JSON round-tripping); the fallback `"perKeyword"`
shape (older library versions / blog examples) is also handled.

If a section fails (e.g. Trends rate-limits the request or the response isn't
JSON), the section is replaced by an error key like
`interestOverTimeError: "..."` so a partial result is still useful.

### Local test

```bash
npm install
npm test           # structural only - no network calls, verifies shape handling
npm run test:live  # also hits live Google Trends; rate-limits are tolerated
```

The structural test asserts that `trimRelated` correctly handles both known
response shapes the google-trends-api library has shipped, that
`batchKeywords` enforces the 5-keyword-per-batch limit, and that `run()`
wires input/output together. The live test additionally exercises the full
upstream round-trip — if Google is currently rate-limiting this IP, every
section will come back with `*Error` keys but the test still passes (the
graceful-degradation path is what we want to verify).

### Deploy

This is a build-only repo. Deploy and publish to the Apify Store is done by
Sky manually.

### Pricing model

PAY\_PER\_EVENT ~$0.002/keyword-batch returned.

# Actor input Schema

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

One or more search terms to compare. 1-5 recommended; Google Trends supports up to 5 terms per request.

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

Two-letter country code (e.g. 'US', 'GB', '' for worldwide). Default empty = worldwide.

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

Either 'today 5-y' (5 years), 'today 12-m' (12 months), 'today 3-m' (90 days), 'today 1-m' (30 days), 'now 7-d' (7 days), 'now 1-d' (1 day), or 'now 4-H' (4 hours). Or custom like '2023-01-01 2024-01-01'.

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

Google Trends category ID to narrow the search (0 = all categories). See https://github.com/pat310/google-trends-api/wiki/Google-Trends-Categories

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

Return a time-series of relative search interest for each keyword over the chosen timeRange.

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

Return a per-region breakdown of interest (which countries/states searched each keyword the most).

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

Return queries that are most related to each keyword, split into 'top' (most searched) and 'rising' (fastest growing).

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

Return topics (entities, not just queries) related to each keyword, split into 'top' and 'rising'.

## `maxRelatedItems` (type: `integer`):

Cap returned related queries/topics per (keyword, kind, rank) to keep payload small.

## Actor input object example

```json
{
  "geo": "",
  "timeRange": "today 12-m",
  "category": 0,
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "maxRelatedItems": 25
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("prodbysky/google-trends-bulk-extractor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("prodbysky/google-trends-bulk-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call prodbysky/google-trends-bulk-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=prodbysky/google-trends-bulk-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Bulk Extractor",
        "description": "Bulk-extract Google Trends data for one or many keywords. Returns interest over time, interest by region, related queries, and related topics in a single run. No rate-limit games required.",
        "version": "0.1",
        "x-build-id": "sT5QH1TnBXf1B74mO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodbysky~google-trends-bulk-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodbysky-google-trends-bulk-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/prodbysky~google-trends-bulk-extractor/runs": {
            "post": {
                "operationId": "runs-sync-prodbysky-google-trends-bulk-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/prodbysky~google-trends-bulk-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-prodbysky-google-trends-bulk-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more search terms to compare. 1-5 recommended; Google Trends supports up to 5 terms per request.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geo": {
                        "title": "Geo / Country code",
                        "type": "string",
                        "description": "Two-letter country code (e.g. 'US', 'GB', '' for worldwide). Default empty = worldwide.",
                        "default": ""
                    },
                    "timeRange": {
                        "title": "Time range",
                        "type": "string",
                        "description": "Either 'today 5-y' (5 years), 'today 12-m' (12 months), 'today 3-m' (90 days), 'today 1-m' (30 days), 'now 7-d' (7 days), 'now 1-d' (1 day), or 'now 4-H' (4 hours). Or custom like '2023-01-01 2024-01-01'.",
                        "default": "today 12-m"
                    },
                    "category": {
                        "title": "Category code",
                        "type": "integer",
                        "description": "Google Trends category ID to narrow the search (0 = all categories). See https://github.com/pat310/google-trends-api/wiki/Google-Trends-Categories",
                        "default": 0
                    },
                    "includeInterestOverTime": {
                        "title": "Include interest over time",
                        "type": "boolean",
                        "description": "Return a time-series of relative search interest for each keyword over the chosen timeRange.",
                        "default": true
                    },
                    "includeInterestByRegion": {
                        "title": "Include interest by region",
                        "type": "boolean",
                        "description": "Return a per-region breakdown of interest (which countries/states searched each keyword the most).",
                        "default": true
                    },
                    "includeRelatedQueries": {
                        "title": "Include related queries (top + rising)",
                        "type": "boolean",
                        "description": "Return queries that are most related to each keyword, split into 'top' (most searched) and 'rising' (fastest growing).",
                        "default": true
                    },
                    "includeRelatedTopics": {
                        "title": "Include related topics (top + rising)",
                        "type": "boolean",
                        "description": "Return topics (entities, not just queries) related to each keyword, split into 'top' and 'rising'.",
                        "default": false
                    },
                    "maxRelatedItems": {
                        "title": "Max related items per section",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap returned related queries/topics per (keyword, kind, rank) to keep payload small.",
                        "default": 25
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
