# Google Trends Scraper - Interest, Regions & Rising Queries (`snappytools/google-trends-scraper`) Actor

Extract Google Trends interest over time, regions, US cities and metros, rising queries with Breakout flags, and Trending now searches by country. Automatic retries, a status row for every term, and you never pay for empty results.

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

## Pricing

from $0.25 / 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 – Interest, Regions & Rising Queries | $0.25 per 1,000

Extract Google Trends data for any search term or topic: **interest over time, interest by state, country, city and US metro, and the top and rising related queries, with Breakout flags**, plus **Trending now**: what people are searching for right now in any country, with the news stories behind each trend. Built for marketers, SEO teams, product researchers and analysts who need Trends data that arrives complete, every run, without babysitting.

Every search term gets a **status row** that tells you exactly what was collected, every empty section is **re-checked automatically**, and you are **never charged for data Google didn't return**.

### Why this Google Trends scraper?

Google Trends has no official public API, so scrapers break in predictable ways: runs that crash, runs that "succeed" with nothing in them, and missing sections such as rising queries or regional data. This tool was built around fixing exactly those problems.

| | Typical Google Trends scrapers | This scraper |
|---|---|---|
| Interest over time | ✅ | ✅ |
| Interest by state/region or country | Often empty or zeros | ✅ Re-checked if empty, zero-padding removed |
| US metro areas (DMA) | ❌ | ✅ |
| Top **and** rising related queries | Rising list often missing | ✅ Both lists, with Breakout flags |
| City-level data | Often empty with no explanation | ✅ Optional (US and some countries), with map coordinates, never charged when empty |
| Blocked or throttled by Google | Run fails | ✅ Automatic retries on a fresh connection |
| Unexpected errors | Run crashes | ✅ Caught and reported per term; the run always finishes |
| Empty results | Often silent, and still charged | ✅ Explained in a status row, never charged |
| Compare up to 5 terms on one scale | Rare | ✅ |
| Paste Google Trends links directly | Sometimes | ✅ Keeps each link's own settings |
| Plain-English insights per term | ❌ | ✅ Peak, trend direction, fastest-rising search, top region |
| Trending now (today's trending searches) | Sometimes | ✅ Built in: many countries per run, traffic as a number, linked news articles |

### What data you get

Every row shares these columns, so the dataset reads as one clean spreadsheet: `searchTerm`, `comparedWith`, `geo`, `timeRange`, `category`, `searchProperty`, `dataType`, `label`, `value`, `formattedValue`.

| `dataType` | What it is | Extra fields | Example |
|---|---|---|---|
| `interestOverTime` | Popularity 0–100 for each day, week or month in your range | `date`, `isPartial` | 5 Oct 2026 → 78 |
| `interestByRegion` | Popularity 0–100 by place | `regionLevel` (country, state/region, city, metro), `geoCode`, `latitude`, `longitude` | Wyoming (US-WY) → 100 |
| `relatedQueryTop` | Most searched related queries | `rank`, `link` | "e bike price" → 100 |
| `relatedQueryRising` | Fastest-growing related queries | `rank`, `isBreakout`, `link` | "best pickleball paddles 2026" → +3,300% |
| `trendingNow` | A search trending right now in a country | `rank`, `date` (when it started trending), `newsArticles`, `picture`, `link` | "austin weather" → 200+ (value 200) |
| `summary` | One plain-English insight per term | `summary` | "Interest peaked at 100 on 5 Oct 2026…" |
| `status` | What was collected for this term (free) | `sections`, `message`, `resultsCharged` | complete / partial / no data from Google / failed |

The **Output** tab has ready-made views: All results, Interest over time, Interest by region, Related queries, Trending now, and Run status per term. Filter by `dataType` in any export to split the data however you like.

A run summary (terms complete, partial, without data, failed, and results charged) is also saved as `OUTPUT` in the run's key-value store.

### Who uses it

| Who | What they do with it |
|---|---|
| SEO and content teams | Find rising queries to write about before they peak |
| Marketers and agencies | Time campaigns to seasonal peaks and pick the regions to target |
| Ecommerce and product teams | Validate demand before launching or stocking a product |
| Analysts and researchers | Build long-run datasets of public interest by topic and place |
| Investors and founders | Track interest in brands, categories and competitors over time |
| Newsrooms and social media teams | See what's trending today and the stories behind it |
| AI agents and automations | Feed fresh trend signals into reports, dashboards and alerts |

### How to use it

1. Choose **what to scrape**: search terms, or **Trending now**. Then enter your search terms (or paste Google Trends links), or pick the countries you want trends for.
2. For search terms, choose a **country** (or Worldwide) and a **time range**.
3. Tick the **sections** you want. The main ones are on by default; city and US metro data are optional.
4. Click **Start** and watch results appear in the Output tab.
5. Download as Excel, CSV, JSON or HTML, or connect the results to your tools.

### Input example

```json
{
  "searchTerms": ["pickleball", "padel"],
  "geo": "US",
  "timeRange": "today 12-m",
  "compareMode": false,
  "includeInterestOverTime": true,
  "includeRegions": true,
  "includeCities": false,
  "includeRelatedQueries": true,
  "includeSummary": true
}
```

Trending now example (no search terms needed):

```json
{
  "mode": "trendingNow",
  "trendingCountries": ["US", "GB", "CA"],
  "includeNewsArticles": true
}
```

Useful inputs:

- **Country:** pick from the list, or leave as Worldwide (regions are then countries). For a state, add a **Region code** such as `US-CA` or `US-TX`.
- **Time range:** past hour, 4 hours, day, 7 days, 30 days, 90 days, 12 months, 5 years, since 2004, or custom dates such as `2024-01-01 2024-06-30`.
- **Search type:** web, image, news, Google Shopping or YouTube search.
- **Category:** pick a Google Trends category from the list, such as Shopping or Health.
- **Compare mode:** compares up to 5 terms on one shared scale, like the comparison view on Google Trends.
- **Google Trends URLs:** paste links copied from trends.google.com; each keeps its own terms, location, dates, category and search type.

### Output example

```json
[
  {
    "searchTerm": "pickleball",
    "geo": "US",
    "timeRange": "today 12-m",
    "dataType": "relatedQueryRising",
    "rank": 2,
    "label": "best pickleball paddles 2026",
    "value": 3300,
    "formattedValue": "+3,300%",
    "isBreakout": false,
    "link": "https://trends.google.com/trends/explore?q=best+pickleball+paddles+2026&date=today+12-m&geo=US"
  },
  {
    "searchTerm": "pickleball",
    "geo": "US",
    "dataType": "status",
    "label": "partial",
    "resultsCharged": 155,
    "sections": {
      "interestOverTime": "ok",
      "interestByRegion": "ok",
      "interestByCity": "empty: Google has no city data for this search",
      "relatedQueries": "ok"
    },
    "message": "City data: Google has no city data for this search. You were not charged for missing sections."
  }
]
```

### Pricing

**$0.25 per 1,000 results.** A result is one data row: one date, one place, one related query, one trending search, or one summary.

- **Status rows are free.** Failed and empty sections cost nothing.
- **One term, default settings, past 12 months:** typically 150–250 results, about $0.04–$0.06.
- **100 terms, interest over time only, past 12 months:** about 5,200 results, about $1.30.
- **Trending now for 5 countries:** about 50 results (Google lists about 10 per country), about $0.01. News articles are included at no extra charge.

You can set a maximum spend for any run. When it's reached, the scraper stops cleanly and keeps everything collected so far.

### Reliability, built in

- **Fresh connection on every retry.** If Google throttles or blocks a request, the scraper switches IP, picks up fresh cookies, waits with increasing back-off, and tries again (up to 6 times by default).
- **Empty sections re-checked.** Google sometimes returns a blank section on the first attempt. Anything empty or failed is tried once more before it's reported.
- **No zero-padding.** Places and dates Google marks as "no data" are left out unless you ask for them, so your charts aren't flattened by fake zeros.
- **Never crashes mid-run.** Problems are recorded against the term they affect, and the rest of your terms carry on.
- **Polite pacing.** A short delay between requests (adjustable) keeps runs from being throttled.

### Integrations and scheduling

- **Schedule** runs daily, weekly or monthly in Apify to track trends over time.
- Send results to **Google Sheets, Make, n8n, Zapier, Slack, Airtable** or any webhook.
- Call it from your own code with the **Apify API**, or from **AI assistants** through the Apify MCP server.

### FAQ

**Does it need a Google account or API key?**
No. It reads the same public data you see on trends.google.com.

**Why are some values 0–100 instead of search counts?**
That's how Google Trends works: values are relative popularity, where 100 is the peak for that term, place and time range. Compare mode puts several terms on one shared scale.

**Why did a section come back empty?**
Low-volume terms often have no rising queries or regional data on Google's side. The status row tells you which sections were empty, confirms they were checked twice, and you're not charged for them.

**Where are city data and related topics?**
Google Trends' new Explore page dropped the city view and related topics. City data is still available for the US and some other countries, so it's an optional toggle here (off by default); when Google has none for your search, the status row says so, the tool moves on in seconds, and you pay nothing. Related topics are no longer returned by Google, so this tool doesn't pretend to offer them.

**How does Trending now work, and how often should I run it?**
It reads Google's own trending-searches feed for each country you pick. Google lists about 10 searches per country, most recent first. For each one you get the search, its approximate number of searches (e.g. "2K+", also given as a number), when it started trending, and the news stories Google links to it. The list changes through the day, so schedule it hourly or daily to build a history. Each trend has a link to explore it further on Google Trends.

**What does "Breakout" mean?**
Google labels a rising query "Breakout" when it grew by more than 5,000%. Those rows have `isBreakout: true`.

**How fresh is the data?**
Live. Every run reads Google Trends at that moment. The newest period may be marked `isPartial: true` because it isn't finished yet.

**Which proxy should I use?**
Residential proxies (the default) give the most reliable results with Google. The requests are small, so proxy cost per run is low.

**Is scraping Google Trends legal?**
This tool collects publicly available, aggregated data only. No personal data is involved. You're responsible for how you use the results and for following Google's terms.

**Something isn't working. What should I do?**
Open an issue on the Issues tab with your input and run link. Issues are usually answered within one business day.

### Related tools

More tools from this developer are listed on the developer's Apify profile.

***

This tool is not affiliated with, endorsed by, or sponsored by Google. Google Trends is a trademark of Google LLC.

# Actor input Schema

## `mode` (type: `string`):

Search terms looks up the words you enter. Trending now lists what people are searching for right now in the countries you pick (no search terms needed).

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

Words or phrases to look up, one per line. You can also paste a Google topic ID such as /m/0k8z. Leave empty if you only use Google Trends URLs below.

## `startUrls` (type: `array`):

Paste explore links copied from trends.google.com. Each link keeps its own terms, location, date range, category and search type.

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

Used when 'What to scrape' is Search terms. Choose a country, or leave as Worldwide. For a state or region, also fill in Region code below.

## `region` (type: `string`):

For a state or region inside the chosen country, e.g. US-CA (California), US-TX (Texas), GB-ENG (England). Overrides Country when filled in.

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

How far back to look. Choose 'Custom' to set exact dates below.

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

Only used when Time range is 'Custom dates'. Format: start date, a space, end date. Example: 2024-01-01 2024-06-30

## `category` (type: `string`):

Narrow results to one Google Trends category, e.g. 'apple' in Food & Drink vs Computers & Electronics.

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

Which Google search to measure.

## `trendingCountries` (type: `array`):

Used when 'What to scrape' is Trending now. Pick one or more countries; each gives about 10 trending searches. Leave empty to use the country above (or the United States).

## `maxTrendingItems` (type: `integer`):

Google's feed lists about 10 trending searches per country, in Google's order (most recent first). Lower this to cap cost.

## `includeNewsArticles` (type: `boolean`):

Adds the news stories Google links to each trending search (title, source, URL, image). No extra charge.

## `compareMode` (type: `boolean`):

On: terms are compared in groups of up to 5, so values are relative to each other, exactly like the comparison view on Google Trends. Off: each term is measured on its own 0-100 scale.

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

The 0-100 popularity line across your time range.

## `includeRegions` (type: `boolean`):

Popularity by state/region (or by country for worldwide searches).

## `includeCities` (type: `boolean`):

Off by default. Google Trends now offers city data mainly for the US and a few other countries. Includes latitude and longitude. When Google has no city data for your search, the status row says so and nothing is charged.

## `includeMetros` (type: `boolean`):

Only works when the location is the US or a US state.

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

Top and rising related search queries, with Breakout flags.

## `includeSummary` (type: `boolean`):

Adds one plain-English row per term: peak, latest versus average, overall direction, fastest-rising search and strongest region.

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

Up to 50 top and 50 rising queries per term, when Google has that many. Lower it to save cost.

## `includeZeroValues` (type: `boolean`):

Off by default so your results are not padded with zero rows.

## `recheckEmptySections` (type: `boolean`):

If a section comes back empty or fails, try it once more on a fresh connection before reporting it.

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

How many times to retry a blocked or failed request on a fresh IP before giving up on that section.

## `delayBetweenRequestsMs` (type: `integer`):

A short pause keeps Google from throttling the run.

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

Language for place and topic names, e.g. en-US, en-GB, de, fr.

## `timezone` (type: `string`):

Time zone for dates, e.g. UTC, America/New_York, Europe/London.

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

Residential proxies give the most reliable results with Google.

## Actor input object example

```json
{
  "mode": "explore",
  "searchTerms": [
    "pickleball",
    "padel"
  ],
  "geo": "",
  "region": "",
  "timeRange": "today 12-m",
  "category": "0",
  "searchProperty": "",
  "trendingCountries": [],
  "maxTrendingItems": 10,
  "includeNewsArticles": true,
  "compareMode": false,
  "includeInterestOverTime": true,
  "includeRegions": true,
  "includeCities": false,
  "includeMetros": false,
  "includeRelatedQueries": true,
  "includeSummary": true,
  "maxRelatedItems": 50,
  "includeZeroValues": false,
  "recheckEmptySections": true,
  "maxRetries": 6,
  "delayBetweenRequestsMs": 1000,
  "language": "en-US",
  "timezone": "UTC",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every data row plus one free status row per search term.

## `interestOverTime` (type: `string`):

No description

## `interestByRegion` (type: `string`):

No description

## `relatedQueries` (type: `string`):

No description

## `trendingNow` (type: `string`):

No description

## `runStatus` (type: `string`):

No description

## `runSummary` (type: `string`):

Counts of complete, partial and failed terms, and results charged.

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

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

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

```

## MCP server setup

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