# Google Trends Scraper – Interest, Regions & Trending Now (`phantom-x64/google-trends-scraper`) Actor

Extract Google Trends data: interest over time, interest by region, related queries and topics, keyword comparison (up to 5 terms) and Trending Now with search volume. No API key or login. A Google Trends API alternative. $1.50 per 1,000 keyword reports.

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

## Pricing

from $1.50 / 1,000 keyword 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 over time, regions, related queries & Trending Now

**Google Trends scraper and Google Trends API alternative.** Get **interest over time**, **interest by country, state, metro area or city**, **related queries** (top and rising, including *Breakout* terms), related topics (experimental), **side-by-side comparisons of up to 5 keywords**, and today's **Trending Now** searches with search volume — as clean JSON, CSV or Excel. No browser, no Google account, no API key.

- ✅ **Keyword trends** for any term, topic id (`/m/05p0rrx`) or pasted Google Trends URL
- ✅ **Compare up to 5 keywords** on the same 0-100 scale (`chatgpt, gemini, claude`) + share of each term per region
- ✅ **Any location and period**: worldwide, a country (`US`, `ES`), a state (`US-CA`); past hour → 2004-present, or a custom date range
- ✅ **Categories and Google properties**: Web, Images, News, Shopping, **YouTube search**
- ✅ **Trending Now** per country: search volume (e.g. `2M+`), % increase, start time, active/ended, categories, related searches, news
- ✅ Ready-made metrics per keyword: **average, peak, latest value and % change** over the period
- ✅ Two output formats: one row per keyword (nested JSON) or **flat rows ready for Google Sheets / Excel**
- ✅ **Built for reliability**: cookie sessions, exponential backoff, a fresh IP + cookie on every `429`, automatic switch to residential proxy when Google keeps blocking — and free error rows instead of crashed runs
- ✅ **$1.50 per 1,000 keywords, no start fee** — half the price of the most popular Google Trends actor

### What can you do with this Google Trends scraper?

| Use case | How |
|---|---|
| **SEO & content planning** | Find rising queries and *Breakout* keywords around your topic; check seasonality before you write. |
| **Keyword research at scale** | Run hundreds of keywords through the same period and location and rank them by average or % change. |
| **Brand & competitor tracking** | Compare your brand with up to 4 competitors; see which states or countries each one leads. |
| **E-commerce & product research** | Use the Google Shopping property and the Shopping category to spot products that are taking off. |
| **YouTube & creators** | Switch the property to YouTube search to see what people look for on YouTube. |
| **News, PR & social media** | Pull Trending Now every hour for your countries and react to what is spiking right now. |
| **Data science & AI** | Feed clean time series into dashboards, forecasting models, LLM agents or Google Sheets. |

### Quick start (under 1 minute)

1. Click **Try for free** and type the keywords to analyze. Separate up to 5 terms with commas to compare them on the same 0-100 scale.
2. Pick the country (`geo`), the time range and the sections you want (interest over time, regions, related queries). Leave *Trending Now* empty unless you need it.
3. Click **Start**. One keyword usually finishes in 10-30 seconds. Download JSON, CSV or Excel, or call it through the Apify API.

### Input

| Field | What it does |
|---|---|
| `searchTerms` | One entry per query: `bitcoin`, a comparison `nike, adidas, puma` (max 5), a topic id `/m/05p0rrx`, or a Trends URL. |
| `geo` | `US`, `GB`, `ES`, `US-CA`… Empty = worldwide. |
| `timeRange` / `customTimeRange` | `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 `2024-01-01 2024-06-30`. |
| `category` / `searchProperty` | Category id (0 = all) and Web / Images / News / Shopping / YouTube. |
| `compareAllTerms` | Put all search terms in one comparison. |
| `includeInterestOverTime`, `includeInterestByRegion`, `includeRelatedQueries`, `includeRelatedTopics` | Choose the sections you need. |
| `regionResolution` | Auto, countries, subregions, US metro areas (DMA) or cities. |
| `trendingGeos`, `trendingHours`, `trendingSort`, `trendingCategories`, `maxTrendingPerCountry` | Trending Now per country (past 4 h / 24 h / 48 h / 7 days). |
| `outputFormat` | `report` (one row per keyword) or `flat` (one row per data point). |
| `proxyConfiguration` | Apify Proxy (recommended). |

#### Example: compare three AI assistants in the US over 90 days

```json
{
  "searchTerms": ["chatgpt, gemini, claude"],
  "geo": "US",
  "timeRange": "today 3-m"
}
```

#### Example: 5-year YouTube trend of a product in Spain, from a Trends URL

```json
{
  "searchTerms": ["https://trends.google.com/trends/explore?q=air%20fryer&geo=ES&date=today%205-y&gprop=youtube"]
}
```

#### Example: today's top trending searches in three countries, sorted by volume

```json
{
  "searchTerms": [],
  "trendingGeos": ["US", "GB", "IN"],
  "trendingHours": "24",
  "trendingSort": "volume",
  "maxTrendingPerCountry": 50
}
```

### Output

Every row has a `type`: `keyword`, `trending` or `error` (errors are free). Real sample from a local test run (shortened):

```json
{
  "type": "keyword",
  "search_term": "claude",
  "comparison_group": ["chatgpt", "gemini", "claude"],
  "geo": "US",
  "time_range": "today 3-m",
  "time_resolution": "DAY",
  "average": 17.72,
  "peak_value": 25,
  "peak_date": "2026-10-22",
  "latest_value": 21,
  "change_pct": 21.4,
  "interest_over_time": [
    {"date": "2026-08-02", "timestamp": 1785628800, "value": 13, "has_data": true, "is_partial": false, "formatted_time": "Aug 2, 2026"}
  ],
  "interest_by_region": [
    {"geo_code": "US-DC", "geo_name": "District of Columbia", "value": 100, "has_data": true},
    {"geo_code": "US-CA", "geo_name": "California", "value": 70, "has_data": true}
  ],
  "compared_by_region": [
    {"geo_code": "US-CA", "geo_name": "California", "share_pct": 17, "is_leader": false}
  ],
  "related_queries_top": [
    {"query": "claude ai", "value": 100, "formatted_value": "100", "is_breakout": false, "link": "https://trends.google.com/trends/explore?q=claude+ai&date=today+3-m&geo=US"}
  ],
  "related_queries_rising": [
    {"query": "claude duet", "value": 3100, "formatted_value": "+3,100%", "is_breakout": false, "link": "..."}
  ],
  "related_topics_status": "not_offered_by_google_for_comparisons",
  "explore_url": "https://trends.google.com/trends/explore?q=chatgpt%2Cgemini%2Cclaude&date=today+3-m&hl=en-US&geo=US"
}
```

```json
{
  "type": "trending",
  "rank": 1,
  "geo": "US",
  "term": "learjet 60",
  "search_volume": 2000000,
  "search_volume_text": "2M+",
  "increase_pct": 1000,
  "started_at": "2026-11-01T19:10:00Z",
  "ended_at": null,
  "is_active": true,
  "categories": ["Other"],
  "trend_breakdown": ["learjet 60", "plane crash florida", "florida plane crash"],
  "news": [],
  "explore_url": "https://trends.google.com/trends/explore?q=learjet+60&geo=US&date=now+1-d&hl=en-US"
}
```

With `outputFormat: "flat"` you get rows of type `summary`, `interest_over_time`, `interest_by_region`, `compared_by_region`, `related_query` and `related_topic`, each with `search_term`, `geo` and `time_range` — perfect for a pivot table.

### Pricing

Pay per event — you only pay for data you get:

| Event | Price |
|---|---|
| Keyword report (one term in one location & period, all sections included) | **$0.0015** ($1.50 per 1,000 keywords) |
| Trending search (one Trending Now row) | **$0.0005** ($0.50 per 1,000) |
| Run start | **free** |
| Error rows | free |

Examples: 100 keywords ≈ **$0.15**. A 5-keyword comparison ≈ **$0.0075**. Tracking one keyword every hour for a month ≈ **$1.08**. Set "Max cost per run" in the run options to cap any run — the scraper stops before starting a query it cannot pay for.

### FAQ

**Is there an official Google Trends API?** Google has announced an alpha API with limited access. This actor reads the same public JSON that the trends.google.com website loads in your browser, so it works today, for any keyword, without an application.

**Why do the values go from 0 to 100?** That is how Google Trends works: values are relative to the highest point in the chosen period and location (100 = peak popularity). In a comparison all terms share the same scale.

**What about related topics?** They are an opt-in, experimental section (`includeRelatedTopics`). Google never shows related topics for comparisons, and at the moment it returns the topic list empty for most automated requests. The field `related_topics_status` tells you what happened (`ok`, `empty_from_google`, `not_offered_by_google_for_comparisons`) and you are charged the same either way, so leave it off unless you need it. Related queries (top and rising) are not affected.

**Why do I get HTTP 429 in other tools?** Google rate-limits Trends aggressively: in our tests one IP gets blocked after roughly 60 requests in a few minutes, and stays blocked for more than half an hour. This actor gives every query its own IP and cookie, moves to a fresh IP before reaching that limit, waits with exponential backoff, changes IP on every retry, restarts a failed query once from scratch and can switch to residential proxy automatically. Each run saves `RUN_SUMMARY` in the key-value store with the success rate, number of retries and blocked responses.

**How many keywords can I run?** As many as you want; they run in parallel (3 at a time by default). For very large lists, keep `maxConcurrency` moderate so Google does not rate-limit you.

**What does "Breakout" mean?** In rising related queries, Google marks terms that grew more than 5,000% as *Breakout*; we expose it as `is_breakout: true`.

**Where does Trending Now data come from?** From the Trending Now page of Google Trends (all trends Google lists for the country and time window) plus the official Trending RSS feed for news articles, which Google only provides for its most recent top trends.

**Is it legal?** The actor only reads aggregated, anonymous statistics that Google publishes openly, without logging in and without solving captchas. Check Google's terms for your use case.

### Limits

- Google Trends values are relative (0-100 against the peak of the chosen period and place), not absolute search volumes. Only *Trending Now* includes volume buckets.
- Google rate-limits Trends hard. The Actor rotates IPs and retries, and can fall back to residential proxy, but a busy moment can slow a run.
- Related topics are experimental and often come back empty from Google; the field `related_topics_status` says what happened.
- A comparison supports up to 5 terms.

### Use it from code (API)

Every Apify Actor is also an API. Replace `<YOUR_API_TOKEN>` with the token from your Apify account (Settings, API & Integrations).

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('phantom-x64/google-trends-scraper').call({
    "searchTerms": [
      "bitcoin",
      "chatgpt, gemini, claude"
    ],
    "geo": "US",
    "timeRange": "today 3-m"
  });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_API_TOKEN>')
run = client.actor('phantom-x64/google-trends-scraper').call(run_input={
      "searchTerms": [
        "bitcoin",
        "chatgpt, gemini, claude"
      ],
      "geo": "US",
      "timeRange": "today 3-m"
    })
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

You can also start it from Make, Zapier, n8n or Google Sheets with the Apify integrations, schedule it, or call it as a tool from an AI agent through the Apify MCP server.

### Support and feedback

Found a bug, need a new field or another source? Open an issue in the **Issues** tab of this Actor page. Reports with a run link are fixed fastest. If it saves you time, a short review on the Store page helps other people find it.

# Actor input Schema

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

Keywords to analyze. One entry = one Google Trends query. Separate up to 5 terms with commas to COMPARE them on the same scale ("chatgpt, gemini, claude"). You can also paste a Google Trends explore URL (https://trends.google.com/trends/explore?q=...) or a topic id such as /m/05p0rrx.

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

Country or region code: US, GB, ES, DE, US-CA, ES-GA... Leave empty for worldwide. Explore URLs keep their own geo.

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

Period to analyze. Google picks the resolution: minutes (past hour/4 hours), 8 minutes (past day), hours (7 days), days (up to 9 months), weeks (12 months / 5 years), months (since 2004).

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

Optional exact period "YYYY-MM-DD YYYY-MM-DD", e.g. "2024-01-01 2024-06-30" (daily data up to ~9 months, weekly beyond). Leave empty to use the time range above.

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

Google Trends category to narrow ambiguous terms (0 = all categories). Examples: 3 Arts & Entertainment, 5 Computers & Electronics, 7 Finance, 12 Business & Industrial, 16 News, 18 Shopping, 20 Sports, 44 Beauty & Fitness, 45 Health, 47 Autos & Vehicles, 67 Travel, 71 Food & Drink, 958 Jobs & Education. The id is the cat= value of a Trends URL.

## `searchProperty` (type: `string`):

Which Google search to measure: Web search (default), Image search, News search, Google Shopping or YouTube search.

## `compareAllTerms` (type: `boolean`):

Put every search term in a single comparison (max 5 terms), as if you had typed them with commas in one entry.

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

Timeline of search interest (0-100) with average, peak, latest value and % change between the first and last quarter of the period.

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

Search interest by country, subregion, metro area or city (for comparisons also the share of each term per region).

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

Level of the region breakdown. Auto = countries for worldwide, subregions (states/provinces) for a country. Metro areas (DMA) exist mainly for the US.

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

Also return regions where Google has too little data (value 0, has_data false).

## `maxRegions` (type: `integer`):

Keep only the top N regions per term (0 = all).

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

Top and rising related search queries (rising ones include "Breakout" queries growing over 5000%).

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

Top and rising related topics (Knowledge Graph entities). Experimental: Google does not offer them for comparisons and currently returns the list empty for most automated requests (one extra request per term). The field related_topics_status tells you what happened.

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

Maximum queries/topics kept in each related list (top and rising) and in the related searches of each trending search. 0 = all that Google returns.

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

Country codes (US, GB, ES, IN...) for which to get today's "Trending now" searches: search volume, % increase, start time, categories, related searches and news. Leave empty to skip.

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

Trends started in the past 4, 24, 48 hours or 7 days.

## `maxTrendingPerCountry` (type: `integer`):

Maximum trending searches per country, in Google's order (0 = all, usually several hundred).

## `trendingSort` (type: `string`):

Order of the trending searches before the max-items limit is applied: Google's relevance order (rank), search volume, or most recent start time.

## `trendingCategories` (type: `array`):

Optional filter, e.g. Sports, Technology, Entertainment, Business and Finance, Politics, Health, Games, Shopping, Climate. Leave empty for all.

## `trendingActiveOnly` (type: `boolean`):

Skip trends that Google already marks as ended.

## `trendingIncludeNews` (type: `boolean`):

Attach the news articles Google shows for the top trends (from the official Trending RSS feed; usually the top 10 per country).

## `outputFormat` (type: `string`):

Report = one row per keyword with all data nested (best for JSON/API). Flat = one row per data point (date, region, related query...) ready for CSV, Excel or Google Sheets; the price is the same (charged per keyword).

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

Language code for topic names, region names and dates (hl), e.g. en-US, es, de, fr.

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

How many queries run at the same time, each with its own IP and cookie. Higher is faster but more likely to hit Google's rate limits.

## `requestDelayMs` (type: `integer`):

Pause between two requests of the same session (a random jitter is added). Google rate-limits fast clients.

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

Retries after HTTP 429, a bot check or a network error, each with a new IP, a new cookie and exponential backoff. A failed query is also restarted once from scratch.

## `autoResidentialFallback` (type: `boolean`):

If Google keeps blocking the selected proxy, automatically switch to Apify RESIDENTIAL proxy for the rest of the run (no extra cost for you).

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

Apify Proxy is strongly recommended: Google Trends answers 429 (too many requests) to IPs that send many queries.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin"
  ],
  "geo": "US",
  "timeRange": "today 3-m",
  "category": 0,
  "searchProperty": "web",
  "compareAllTerms": false,
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "regionResolution": "AUTO",
  "includeLowVolumeRegions": false,
  "maxRegions": 250,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "maxRelatedItems": 25,
  "trendingHours": "24",
  "maxTrendingPerCountry": 100,
  "trendingSort": "relevance",
  "trendingActiveOnly": false,
  "trendingIncludeNews": true,
  "outputFormat": "report",
  "language": "en-US",
  "maxConcurrency": 3,
  "requestDelayMs": 1200,
  "maxRetries": 5,
  "autoResidentialFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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": [
        "bitcoin"
    ],
    "geo": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("phantom-x64/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"],
    "geo": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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