# Google Trends Scraper - Interest Over Time, Regions & Trending (`datawright/google-trends-scraper`) Actor

Google Trends data without the hassle: interest over time, interest by country/state/city, top and rising related queries for any search terms - plus everything trending now in any country. Compare terms, any time range, category or property (web, YouTube, News, Shopping). Fast, reliable, flat rows.

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

## Pricing

from $2.50 / 1,000 search term analyseds

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, Interest by Region, Related Queries & Trending Now

Get **Google Trends data as clean JSON, CSV or Excel** - for one search term or thousands:

- 📈 **Interest over time** (0-100) for any time range, from the past hour to 2004-present
- 🗺️ **Interest by region** - countries, states/regions or US metros (DMA)
- 🔍 **Related queries** - top and **rising** (with growth %, or "Breakout")
- 🔥 **Trending now** - every trending search in a country or state, with search volume, % increase, start/end time, category and related searches
- ⚖️ **Compare** up to 5 terms on one chart, exactly like the Trends website
- 🎯 Filter by **country or state**, **category** and **Google property** (Web, YouTube, News, Images, Shopping)

No browser, no Google account, no API key - it talks to the same data endpoints as trends.google.com, paces its requests and retries automatically when Google throttles, so runs finish reliably.

Built for **SEO and content research, product and market research, e-commerce and dropshipping, investing signals, journalism, academic research and AI agents**.

### Quick start

Analyse a few terms over the past 12 months in Australia:

```json
{
  "searchTerms": ["pickleball", "padel", "ozempic"],
  "geo": "AU",
  "timeRange": "today 12-m"
}
```

Compare brands head-to-head over 5 years, as flat rows for a spreadsheet:

```json
{
  "searchTerms": ["nike", "adidas", "hoka", "on running"],
  "compareTerms": true,
  "timeRange": "today 5-y",
  "outputFormat": "timeseries"
}
```

What is trending in the US right now (past 24 hours, sports and entertainment only):

```json
{
  "mode": "trendingNow",
  "trendingGeo": "US",
  "trendingHours": "24",
  "trendingCategories": ["17", "4"]
}
```

YouTube search interest by US state:

```json
{
  "searchTerms": ["minecraft"],
  "geo": "US",
  "property": "youtube",
  "regionResolution": "REGION"
}
```

### Output

#### Keyword analysis (one item per search term)

```json
{
  "searchTerm": "pickleball",
  "comparedWith": [],
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "averageInterest": 62.9,
  "peakInterest": 100,
  "peakDate": "2026-04-12",
  "latestInterest": 48,
  "trendDirection": "falling",
  "hasData": true,
  "interestOverTime": [
    {
      "date": "2025-10-05",
      "value": 51,
      "isPartial": false
    },
    {
      "date": "2025-10-12",
      "value": 51,
      "isPartial": false
    }
  ],
  "interestByRegion": [
    {
      "geoCode": "US-WY",
      "geoName": "Wyoming",
      "value": 100
    },
    {
      "geoCode": "US-UT",
      "geoName": "Utah",
      "value": 64
    }
  ],
  "relatedQueriesTop": [
    {
      "query": "pickleball paddle",
      "value": 100
    }
  ],
  "relatedQueriesRising": [
    {
      "query": "best pickleball paddles 2026",
      "value": 4600,
      "growth": "+4,600%"
    }
  ],
  "trendsUrl": "https://trends.google.com/trends/explore?date=today+12-m&q=pickleball&geo=US"
}
```

`averageInterest`, `peakInterest`, `peakDate`, `latestInterest` and `trendDirection` (rising / falling / flat: the last quarter of the period vs the quarter before) make it easy to **sort hundreds of terms** and spot what is growing.

Prefer spreadsheets? Set **Output format** to flat rows - one row per term x date, per term x region, or per related query.

#### Trending now (one item per trending search)

```json
{
  "query": "buccaneers vs cowboys",
  "geo": "US",
  "searchVolume": 2000000,
  "increasePercent": 1000,
  "startedAt": "2026-10-08T08:40:00.000Z",
  "endedAt": null,
  "isActive": true,
  "categories": [
    "Sports"
  ],
  "relatedQueries": [
    "cowboys vs buccaneers",
    "jalon daniels",
    "bucky irving"
  ],
  "timeWindowHours": 24,
  "trendsUrl": "https://trends.google.com/trends/explore?q=buccaneers%20vs%20cowboys&geo=US&date=now%201-d"
}
```

`searchVolume` is Google's volume bucket (2000000 = "2M+ searches").

### Pricing

Simple and predictable - see the **Pricing** tab:

- **Keyword analysis: per search term** - one price covers the timeline, regions and related queries for that term, whatever output format you choose. A term Google refuses after all retries is **not charged**.
- **Trending now: per trending search** returned.

Set a maximum cost per run and the actor stops before going over it.

### Tips

- **How to read the numbers:** Google Trends values are relative - 100 is the term's peak popularity in the chosen time and place, 50 is half as popular. They are not search counts. In compare mode, all terms share one scale (the most popular term peaks at 100) and the region values are each term's **share** of searches.
- **Many terms?** Each term is analysed separately (comparable within itself). Turn on *Compare terms* to put up to 5 on the same scale.
- **States and metros:** set *State / region* to a Google region code such as `US-CA`, `AU-VIC`, `GB-SCT`, `DE-BY` or a US metro like `US-NY-501`.
- **Custom periods:** choose *Custom* and enter `2025-01-01 2025-06-30`.
- **Schedule it:** run daily or weekly (Schedules → Create) to build your own Trends history, and connect to Google Sheets, Zapier, Make or n8n from the Integrations tab.

### FAQ

**Is there an official Google Trends API?** Google's official Trends API is in limited alpha. This actor gives you the same data the Trends website shows, available to anyone today.

**Why do some terms have no data?** Google only reports terms with enough search volume - very rare terms return an empty timeline (`hasData: false`). You are still charged for the lookup, as Google did answer.

**Are related topics included?** Not currently - Google withholds related topics from automated requests. Related queries (top and rising) are included.

**How fast is it?** Roughly 3-6 seconds per search term. Google limits request rates, so the actor paces itself rather than failing.

### Disclaimer

Not affiliated with, endorsed by or connected to Google. Provides publicly available, aggregated Google Trends data. It only reads publicly accessible data and grants you no rights in it: you are responsible for making sure your use complies with the data source's terms of use and applicable laws (including copyright, database and privacy laws).

# Actor input Schema

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

Keyword analysis is charged per search term. Trending now is charged per trending search returned.

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

One term per line (a topic, brand, product or phrase). Each term is analysed on its own unless "Compare terms" is on.

## `compareTerms` (type: `boolean`):

Analyse terms in groups of up to 5, like comparing them on the Trends website - values are then relative to each other (the most popular term peaks at 100) and regions show each term's share.

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

Period to analyse. Short ranges give hourly points, up to 9 months daily, longer ranges weekly or monthly.

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

Used when Time range is "Custom": "YYYY-MM-DD YYYY-MM-DD", e.g. "2025-01-01 2025-06-30".

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

Where the searches come from. For a state or city use the field below.

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

Narrower area, overrides Country: a Google Trends region code such as "US-CA" (California), "AU-VIC" (Victoria) or "GB-SCT" (Scotland), or a US metro (DMA) like "US-NY-501". Also used by Trending now.

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

Restrict to searches in one category (e.g. "jaguar" in Autos vs Pets & Animals).

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

Which Google search the interest comes from.

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

Where the term is most popular (countries, states/regions or US metros).

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

Level of detail for Interest by region. If Google does not offer the chosen level for that place, the automatic level is used (see regionResolution in the output).

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

Top and rising related searches (rising includes the growth %, or "Breakout").

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

Flat rows are easiest in Excel / Google Sheets. The price is per search term either way.

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

Country for Trending now. For a state use the State / region field (e.g. US-CA).

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

How far back trending searches go.

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

Keep only these categories (empty = all).

## `trendingStatus` (type: `string`):

Keep searches that are still trending, have ended, or both.

## `maxItems` (type: `integer`):

Stop after this many dataset items (0 = no limit).

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

Language for region names. Search terms themselves can be in any language.

## Actor input object example

```json
{
  "mode": "keywords",
  "searchTerms": [
    "pickleball",
    "padel"
  ],
  "compareTerms": false,
  "timeRange": "today 12-m",
  "geo": "",
  "category": "0",
  "property": "",
  "includeRegions": true,
  "regionResolution": "",
  "includeRelatedQueries": true,
  "outputFormat": "perTerm",
  "trendingGeo": "US",
  "trendingHours": "24",
  "trendingStatus": "all",
  "maxItems": 0,
  "language": "en-US"
}
```

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

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

# Run the Actor and wait for it to finish
run = client.actor("datawright/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"
  ]
}' |
apify call datawright/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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