# Google Trends Scraper: Interest, Regions, Related, Trending Now (`cozybit/google-trends-scraper`) Actor

Reliable Google Trends scraper without a browser: interest over time, interest by region (country, state, city), top and rising related queries, and Trending Now with search volumes. Residential IPs matched to your country, clean stable JSON. Trial: 0.00003 USD per keyword until 30 Nov 2026.

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

## Pricing

from $0.01 / 1,000 explore reports

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: interest, regions, related queries and Trending Now

Get Google Trends data as clean, stable records without a browser and without a Google account:

- **Interest over time**: Google's 0-100 interest curve for each keyword.
- **Interest by region**: the same interest by country, state/region, city or US metro area.
- **Related queries**: the top and rising searches people make together with your keyword.
- **Trending Now**: what is trending in a country right now, with search volume, growth and related searches.
- **Related topics (experimental)**: see [Limits](#limits) before relying on it.

Prices include all platform costs: you pay per useful record and nothing for proxies or compute.

### What Google Trends numbers mean

Google Trends values are **relative, from 0 to 100**, not search counts. 100 is the peak of interest within one request (one keyword, place and time range); 50 means half as much interest as the peak. Two keywords are only on the same scale when you compare them in one request (turn on **Compare keywords**). Trending Now gives Google's own approximate search volumes ("2,000,000+").

### Input

| Field | What it does | Default |
|---|---|---|
| Reports to collect | Any of interest over time, interest by region, related queries, related topics, Trending Now | the first three |
| Keywords | 1-200 search terms | `coffee` |
| Compare keywords | Put 2-5 keywords on one shared 0-100 scale | off |
| Explore location | Empty for worldwide, a country (`US`), a region (`US-CA`) or a US metro area (`US-CA-807`) | worldwide |
| Explore time range | Past hour up to "since 2004", or custom dates | past 12 months |
| Explore category ID, Search type | Narrow to a Google category or to News, Images, YouTube or Shopping search | all, web |
| Regional detail | Google's default level or cities | Google's default |
| Trending Now country, time range, category, maximum rows | Which trending searches to return (4 hours to 7 days, 19 categories, up to about 500 rows) | US, 24 hours, all, 50 |

Example: interest over time, regions and related queries for two keywords in Germany:

```json
{
  "keywords": ["iphone 17", "pixel 10"],
  "geo": "DE",
  "timeframe": "today 3-m"
}
```

Example: the top 100 trending searches in the UK in the past 4 hours:

```json
{
  "reports": ["trending_now"],
  "trendingGeo": "GB",
  "trendingHours": "4",
  "trendingMaxItems": 100
}
```

### Output (record format v1)

Every record has `type`, `status` (`ok`, `no_data` or `error`), `error`, `keyword`, `keywords`, `geo`, `timeframe`, `category`, `property`, `source_url` (the matching Google Trends page) and `scraped_at`. Field names in format v1 do not change; any future change will be announced here first.

Interest over time (one record per keyword):

```json
{
  "type": "interest_over_time", "status": "ok", "error": null,
  "keyword": "coffee", "keywords": ["coffee"], "geo": "US", "timeframe": "today 12-m",
  "category": 0, "property": "", "resolution": "WEEK", "average": null,
  "values": [{ "date": "2025-10-26T00:00:00.000Z", "value": 57, "is_partial": false }],
  "source_url": "https://trends.google.com/trends/explore?q=coffee&geo=US&date=today+12-m&cat=0&hl=en-US",
  "scraped_at": "2026-10-30T00:45:38.048Z"
}
```

`average` is filled only when Google provides it (keyword comparisons). Dates are UTC; the last point is often `is_partial` because the period is still running.

Interest by region: `resolution` (`COUNTRY`, `REGION`, `CITY` or `DMA`) and `values: [{ "geo_code": "US-WY", "geo_name": "Wyoming", "value": 100 }]`. City rows have `geo_code: null` because Google gives no code for them.

Related queries: `top` and `rising`, each a list of `{ "query", "value", "formatted", "link" }`. For rising queries `formatted` is the growth Google shows, such as `+250%` or `Breakout`. Related topics use `topic: { "mid", "title", "type" }` instead of `query`.

Trending Now (one record per trending search):

```json
{
  "type": "trending_now", "status": "ok", "error": null, "keyword": null, "keywords": [],
  "geo": "US", "timeframe": "past 24 hours", "category": null, "property": "",
  "rank": 1, "title": "patrick stewart", "search_volume": 2000000, "increase_pct": 1000,
  "started_at": "2026-10-29T19:30:00.000Z", "ended_at": null, "active": true,
  "categories": [{ "id": 4, "name": "Entertainment" }],
  "related_queries": ["sir patrick stewart", "captain picard"], "hours": 24,
  "source_url": "https://trends.google.com/trending?geo=US&hours=24&hl=en-US",
  "scraped_at": "2026-10-30T00:45:41.658Z"
}
```

`status: "no_data"` means Google had nothing for this request, for example a keyword with too little search volume or a report Google does not offer for it. `status: "error"` means the request failed after all retries; `error` says why. You never pay for `no_data` or `error` records. A run summary (`RUN_SUMMARY`) is saved in the run's key-value store.

### Use it from code

Get your API token from Apify Console > Settings > Integrations.

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("cozybit/google-trends-scraper").call(run_input={"keywords": ["iphone", "samsung galaxy"], "geo": "US"})
for record in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(record["type"], record["keyword"], record["status"])
```

JavaScript (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('cozybit/google-trends-scraper').call({ keywords: ['iphone', 'samsung galaxy'], geo: 'US' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

HTTP API (runs the actor and returns the records in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/cozybit~google-trends-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["iphone", "samsung galaxy"], "geo": "US"}'
```

### Pricing

**Trial price until 30 November 2026:** 0.01 USD per 1,000 reports or Trending Now rows (the lowest price Apify allows). From 1 December 2026 this scraper costs 2.00 USD per 1,000 reports and 0.50 USD per 1,000 Trending Now rows. Apify notifies all users before a price change.

You pay per record with data; platform usage (compute and proxies) is included.

| Event | Price |
|---|---|
| Explore report (one keyword, one report type) | 2.00 USD per 1,000 (0.002 USD each) |
| Trending Now row | 0.50 USD per 1,000 (0.0005 USD each) |

Worked examples:

- One keyword with the three default reports: 3 x 0.002 = **0.006 USD**.
- 100 keywords with the three default reports: 300 reports = **0.60 USD**.
- Top 50 trending searches in one country: 50 x 0.0005 = **0.025 USD**.

To cap spending, set a maximum cost per run in the run options; the actor stops cleanly when it is reached.

### Free Apify plan

On the free Apify plan a run returns at most **15 Explore reports and 50 Trending Now rows**. When the limit is reached the run stops and finishes successfully with the status message "Free Apify plan limit reached"; everything collected so far is in the dataset. Any paid Apify plan removes the limit.

### Reliability

In 120 test runs on the Apify platform with default settings (10 countries plus worldwide, time ranges from one day to five years, 1-5 keywords, Trending Now in every third run), **99.9% of reports and trending rows were delivered** (3,077 of 3,080) and no run was blocked by Google. The median run took 20 seconds; 95% finished within 49 seconds.

How it stays reliable: requests use residential IPs in the country you ask about, because Google refuses data when IP and location do not match. Each IP gets a few slow, paced requests, and if Google limits an IP the actor switches to a new one, up to four times per keyword. A daily test run notices changes on Google's side quickly.

### Compared with other Google Trends scrapers on Apify

We ran this actor and the two most-used Google Trends scrapers on Apify with their default settings on the same 4 inputs (1-2 keywords; US, UK and worldwide; 3 months to 5 years):

| | This actor | Most-used scraper (browser-based) | Second most-used scraper |
|---|---|---|---|
| Inputs where all requested keywords came back | 4 of 4 | 1 of 4 (two runs hit our 0.05-0.15 USD cost limit after 7-9 minutes with nothing) | 4 of 4 (one run per keyword) |
| Related queries | yes | yes | not offered |
| Successful runs | 119 of 120 own test runs | 56% of 26,028 public runs in 30 days | 99% of 48,832 public runs in 30 days |

Where several scrapers returned data, the values were identical: they all read the same Google Trends data.

### Limits

- **Related topics** is experimental: Google currently returns it empty to automated requests, browser-based scrapers included, so expect `no_data` (not charged). It starts working again if Google serves the data.
- Use the default residential proxy. Datacenter proxies work for some countries only (in our tests the US, but not Germany or Japan).
- Up to 200 keywords per run, up to 5 per comparison.
- Trending Now returns what Google lists, usually up to about 500 searches per country and time range.
- Google Trends has no generally available official API; when Google changes its site the actor may fail until it is updated.
- Google is testing a new Explore page that asks visitors to sign in. The data this actor uses is still available without signing in. If Google starts requiring a sign-in for it, runs stop with a clear status message, and failed reports are not charged.

### Support

Report problems and feature requests on the actor's **Issues** tab, ideally with the run link.

# Actor input Schema

## `reports` (type: `array`):

Choose the reports you need. Interest values are relative 0-100, not search counts. Free Apify plans are limited to 15 Explore reports and 50 trending rows per run; any paid Apify plan removes these limits.

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

Enter 1-200 keywords. Extra spaces, empty entries and duplicates are removed. Not needed if you only select Trending Now.

## `compare` (type: `boolean`):

Compare 2-5 keywords on one shared 0-100 scale. With this off, each keyword gets its own scale. Comparisons still return a separate record for each keyword and report.

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

Leave empty for worldwide, or enter an uppercase country (US), region (US-CA) or US DMA (US-CA-807). This location applies to Explore reports, not Trending Now.

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

Time range for Explore reports. Google chooses the time interval of the returned values.

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

Optional UTC dates in YYYY-MM-DD YYYY-MM-DD format, for example 2025-01-01 2025-12-31. Overrides the selected Explore time range.

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

Google Trends Explore category number. Use 0 for all categories. These IDs are different from Trending Now categories.

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

Which Google search service to measure for Explore reports.

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

Let Google choose countries, regions, cities or DMAs, or request cities. Cities require a country or region in Explore location; worldwide maps show countries. City records have no geographic code, so geo_code is null.

## `trendingGeo` (type: `string`):

Two-letter uppercase country code for Trending Now, for example US or GB.

## `trendingHours` (type: `string`):

How far back to look for trending searches. Results may include searches that are no longer active.

## `trendingCategory` (type: `string`):

Keep trending searches in this category. Ranking follows Google's order after the category filter.

## `trendingMaxItems` (type: `integer`):

Maximum trending rows to return (1-1000). Google usually has about 500 available, sometimes fewer. Free Apify plans are limited to 50 trending rows and 15 Explore reports per run; any paid Apify plan removes these limits.

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

Residential proxies are recommended to avoid Google's per-IP limits. The Apify Proxy country is set automatically from the report location (US for worldwide Explore). Turn Apify Proxy off for a direct local test.

## Actor input object example

```json
{
  "reports": [
    "interest_over_time",
    "interest_by_region",
    "related_queries"
  ],
  "keywords": [
    "iphone",
    "samsung galaxy"
  ],
  "compare": false,
  "geo": "US",
  "timeframe": "today 12-m",
  "category": 0,
  "property": "",
  "regionResolution": "auto",
  "trendingGeo": "US",
  "trendingHours": "24",
  "trendingCategory": "",
  "trendingMaxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Explore reports and Trending Now searches, including empty results and errors.

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

Report and job counts, request statistics, and any run limits reached.

# 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": [
        "iphone",
        "samsung galaxy"
    ],
    "geo": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("cozybit/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": [
        "iphone",
        "samsung galaxy",
    ],
    "geo": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("cozybit/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": [
    "iphone",
    "samsung galaxy"
  ],
  "geo": "US"
}' |
apify call cozybit/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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