# Google Trends Scraper $1.5/1K - Interest, Regions, Rising (`vladimir_trifonov/google-trends-scraper`) Actor

Extract Google Trends data for any keyword: interest over time, regional breakdown, top and rising related queries. No API key needed.

- **URL**: https://apify.com/vladimir\_trifonov/google-trends-scraper.md
- **Developed by:** [Vladimir Trifonov](https://apify.com/vladimir_trifonov) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 result rows

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper - Interest, Regions & Rising Queries

Extract Google Trends data for any keyword without an API key. This scraper returns
**interest over time**, **interest by region**, and **top and rising related queries** as clean,
flat rows you can drop straight into a spreadsheet, a database, or a BI tool.

Google does not offer a public Trends API. This Actor gives you one.

### What this Actor does

- **Extract Google Trends interest over time** for any search term, from the past hour to 2004
- **Get interest by region** with country, state, or metro-level breakdowns
- **Find rising search queries** before they peak - the single most useful signal in Trends
- **Track related topics** to map out an entire subject area
- **Compare keyword popularity across countries** by running the same term with different regions
- **Export Google Trends data to CSV, JSON, or Excel** in one click
- **Monitor keyword seasonality** by scheduling daily or weekly runs

### Why this Actor is reliable

Most Google Trends tools break, and they all break the same way.

Google's Trends endpoints return `429 Too Many Requests` for any call made without a warmed
session cookie. The widely used `pytrends` library was archived in April 2025 and no longer
performs that step, so anything built on it fails on the very first request. On top of that,
Google enforces its limit **per IP address**, not per session: a single address survives roughly
10-15 requests before it is cut off no matter what cookies it presents.

This Actor handles both problems directly. It warms a real session before every batch of calls,
and it rotates to a fresh residential IP for each keyword, retrying on a new address when Google
pushes back. That is why it keeps working where simpler scrapers stall.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | `["bitcoin"]` | Search terms to analyze. Up to 500 per run. |
| `geo` | string | `""` (worldwide) | Two-letter country code, e.g. `US`, `GB`, `DE`, `KZ`. |
| `timeframe` | string | `today 12-m` | Period to analyze, from `now 1-H` to `all`. |
| `dataTypes` | array | `["timeline","geo","relatedQueries"]` | Which datasets to return. |
| `category` | integer | `0` | Google Trends category ID. `0` means all categories. |
| `language` | string | `en-US` | Interface language for returned labels. |
| `proxyConfiguration` | object | Residential | Residential proxies are strongly recommended. |

The Actor runs with sensible defaults. Press **Start** without changing anything and you will get
12 months of worldwide data for `bitcoin`.

#### Example input

```json
{
  "keywords": ["electric car", "hybrid car", "hydrogen car"],
  "geo": "US",
  "timeframe": "today 12-m",
  "dataTypes": ["timeline", "geo", "relatedQueries"]
}
```

### Output

Every row is flat and self-describing, so you never have to unpack nested JSON. The `type` field
tells you which dataset the row belongs to.

**Interest over time**

```json
{
  "keyword": "electric car",
  "geo": "US",
  "timeframe": "today 12-m",
  "type": "timeline",
  "date": "Aug 4 - Aug 10, 2025",
  "timestamp": 1754265600,
  "value": 73,
  "isPartial": false
}
```

**Interest by region**

```json
{
  "keyword": "electric car",
  "geo": "US",
  "timeframe": "today 12-m",
  "type": "geo",
  "region": "California",
  "regionCode": "US-CA",
  "value": 100
}
```

**Related queries**

```json
{
  "keyword": "electric car",
  "geo": "US",
  "timeframe": "today 12-m",
  "type": "related_query",
  "rank": "rising",
  "query": "cheapest electric car 2026",
  "value": null,
  "formattedValue": "+250%"
}
```

Rows with `"rank": "top"` are the most searched related terms overall. Rows with
`"rank": "rising"` are the fastest growing ones, which is usually where the useful signal is.

### Use cases

**SEO keyword research.** Pull rising related queries for a seed term and you get a list of
searches gaining traction right now. Feed those into your content calendar before the competition
notices them.

**Product and market research.** Compare interest for competing products across regions to decide
where to launch, or confirm whether a category is genuinely growing before committing budget.

**Seasonality planning.** Run a five-year timeframe to see when demand for a product peaks, then
schedule inventory and ad spend against the real curve instead of guesswork.

**Content and media planning.** Track which topics are accelerating in a specific country and time
publication to match.

**Feeding AI agents and RAG pipelines.** Trends data is one of the few genuinely fresh public
signals about human attention. This Actor returns it in a shape that is trivial to embed or pass
to a model as context.

### Pricing

This Actor uses **pay per result**. You are charged per row returned, so a run that fails costs
you nothing. Platform costs such as proxy traffic are included in the per-result price - there are
no separate compute or bandwidth charges to reason about.

A typical keyword with all three data types returns roughly 60-90 rows: about 52 weekly timeline
points for a 12-month range, plus regional rows and up to 50 related queries.

### Tips for best results

- **Keep the keyword list focused.** Google returns relative interest, scaled 0-100 within each
  request. Values are only comparable within a single keyword's own results.
- **Use residential proxies.** They are the default for a reason. Datacenter IPs are recognised and
  throttled by Google almost immediately.
- **Short timeframes give finer granularity.** `now 7-d` returns hourly points; `today 12-m`
  returns weekly ones; `all` returns monthly.
- **Rare keywords legitimately return nothing.** If Google has too little search volume for a term
  it reports no data. That is a real answer, not an error.
- **Rising queries are co-searches, not synonyms.** This surprises people, so it is worth stating
  plainly: `"rank": "top"` returns terms about your keyword (for `yoga mat`: *black yoga mat*,
  *yoga mat bag*, *travel yoga mat*), while `"rank": "rising"` returns whatever is growing fastest
  among people who also searched it. During a sale season that can include unrelated products such
  as *robot vacuum*. This is genuine Google behaviour, not a data error - `top` is what you want
  for keyword research, `rising` is what you want for spotting momentum. A `formattedValue` of
  `Breakout` means growth above 5000%.
- **Narrow with `category` when a word is ambiguous.** "Java" as a programming language and "Java"
  as an island produce very different curves.

### Frequently asked questions

**Do I need a Google account or API key?**
No. The Actor requires no credentials of any kind.

**How many keywords can I process in one run?**
Up to 500. Each keyword is fetched independently on its own rotated IP, so a failure on one does
not affect the others.

**Why do some keywords fail?**
Google rate-limits aggressively. The Actor retries each keyword several times on fresh IP
addresses, but under heavy load a term can still fall through. Failed keywords are listed in the
run log and in the `RUN_SUMMARY` record, and you are not charged for rows that were never returned.

**Can I schedule this to run automatically?**
Yes. Use Apify Schedules to run it hourly, daily, or weekly and append to the same dataset to build
a time series of your own.

**Is the data the same as the Google Trends website?**
Yes. It comes from the same endpoints the website itself calls, so the numbers match what you see
in the browser.

**Can an AI agent call this Actor directly?**
Yes. It supports pay-per-event billing and runs with limited permissions, so it is callable through
the Apify MCP server and payable via x402 without an Apify account.

### Integrations

Connect the output to Google Sheets, Airtable, Slack, Zapier, Make, or any HTTP webhook using
Apify's built-in integrations, or pull results straight from the Apify API in your own code.

# Actor input Schema

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

Search terms to analyze. Each keyword is fetched independently, so you can mix unrelated topics in one run.

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

Two-letter country code to restrict results (US, GB, DE, KZ...). Leave empty for worldwide.

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

Period to analyze.

## `dataTypes` (type: `array`):

Which datasets to return. Fewer types means faster and cheaper runs.

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

Google Trends category ID to narrow the search. 0 means all categories.

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

Interface language for returned labels.

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

Google Trends rate-limits aggressively per IP. Residential proxies are strongly recommended; without them most requests will fail.

## Actor input object example

```json
{
  "keywords": [
    "bitcoin",
    "ethereum"
  ],
  "geo": "US",
  "timeframe": "today 12-m",
  "dataTypes": [
    "timeline",
    "geo",
    "relatedQueries"
  ],
  "category": 0,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Every row from the run: interest over time, interest by region, and related queries.

## `timeline` (type: `string`):

Relative search interest per period, scaled 0-100 within each keyword.

## `regions` (type: `string`):

Relative search interest broken down by country, state, or metro area.

## `related` (type: `string`):

Top and rising related search terms, with growth figures.

## `summary` (type: `string`):

Per-run statistics: keywords requested, succeeded, partial and failed, success rate, and any failure reasons.

# 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": [
        "bitcoin",
        "ethereum"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vladimir_trifonov/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": [
        "bitcoin",
        "ethereum",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vladimir_trifonov/google-trends-scraper").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 '{
  "keywords": [
    "bitcoin",
    "ethereum"
  ]
}' |
apify call vladimir_trifonov/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/a8jks3QIZDUwsUSau/builds/KYz0BPOuAjYzTF2lS/openapi.json