# Google Trends Scraper (`getdataforu/google-trends`) Actor

Google Trends for any keywords or comparisons - interest over time, interest by country, state or region, top and rising related searches - plus everything trending now in any country, with search volume and growth. No API key.

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

## Pricing

from $1.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Get **Google Trends data for any keywords** — interest over time, interest by country, state or region, and the **top and rising searches** around each term — and **everything trending right now** in any country, with search volume and growth. Compare up to 5 terms on the same scale, exactly like the Google Trends website.

No API key, no Google account, no proxies to manage.

### What it's for

- **SEO and content planning** — find rising searches and breakout topics before they peak, and time content to seasonal demand.
- **Market and product research** — is demand for a product growing or fading? Where is it strongest?
- **Brand tracking** — compare your brand with competitors, week by week, country by country.
- **E-commerce** — spot seasonal spikes and regional demand; measure Google Shopping and YouTube interest too.
- **Newsrooms and social media** — what is trending right now in the US, UK, Japan or Brazil, with search volume.
- **AI and data pipelines** — clean JSON ready for dashboards, spreadsheets and LLM workflows.

### What you get

**For each keyword query** (one term, or up to 5 compared):

| | |
|---|---|
| **Interest over time** | Every point of the chart (by hour, day, week or month), on Google's 0–100 scale |
| **Summary per term** | Average, peak value and date, latest value, % change of the latest quarter vs the first |
| **Interest by region** | Countries (worldwide) or states / regions (for a country) |
| **Related searches** | Top 25 and rising 25 per term — rising ones with their growth, or **Breakout** (+5000%) |
| **Link** | The same view on trends.google.com |

**For each Trending now country**: the full list (often 300–1,600 searches) with **search volume** (200K+), **growth** (+1000%), when it started and whether it is still trending, its categories, and the related searches Google groups under it.

Real results from a test run (US, past 12 months):

| Query | Average | Peak | Change | Top rising search |
|---|---|---|---|---|
| matcha | 73 | 100 (Apr 2026) | +21% | — |
| bitcoin | 35 | 100 (Feb 2026) | −46% | — |
| labubu | 33 | 100 (Oct 2025) | −89% | — |
| nike, adidas, puma | 55 / 23 / … | 100 (Apr 2026) | −8% / … | "nike mind 001" — Breakout |

Trending now, past 24 hours: **US 490 searches, Japan 422, Brazil 364, UK 310.**

### Input

```json
{
  "keywords": ["pickleball", "nike, adidas, puma"],
  "geo": "US",
  "timeRange": "today 12-m",
  "property": "web",
  "trendingCountries": ["US", "GB", "JP"],
  "trendingHours": "24"
}
```

| Field | Default | Notes |
|---|---|---|
| `keywords` | — | One query per line; commas compare up to 5 terms. |
| `geo` | Worldwide | 60+ countries. |
| `timeRange` | past 12 months | Past hour to 2004–present, or a custom range (`customTimeRange`: `2024-01-01 2024-06-30`). |
| `property` | web | `web`, `youtube`, `news`, `images`, `shopping`. |
| `category` | 0 | Google Trends category ID. |
| `includeRegions` / `includeRelatedQueries` | `true` | Turn off for a lighter run. |
| `trendingCountries` | — | Two-letter codes; one record per country. |
| `trendingHours` | 24 | 4, 24, 48 or 168 (7 days). |
| `trendingCategories` | all | Sports, Entertainment, Technology, Politics and 15 more. |
| `maxTrendingPerCountry` | 100 | Biggest searches first. |

At least one keyword or one trending country is required.

### Speed and cost

Measured: **11 keyword queries with every widget, plus Trending now for 4 countries, in 21 seconds.** The actor talks to Google Trends directly with a fresh session cookie and only falls back to a proxy if Google keeps refusing.

### You only pay for results you get

Each keyword query and each Trending now country is one result. Searches with too little volume for Google Trends to show are never written to the dataset, so they are never charged; they are listed in `RUN_SUMMARY.failed`.

### Limitations

- **Values are relative (0–100), not search counts** — that is how Google Trends works. Trending now volumes are Google's own ranges ("200K+").
- **Related topics are not included.** Google withholds them from automated sessions; related *queries* (top and rising) are complete.
- Very rare search terms have no data in Google Trends.

### Legal

Reads only what Google Trends shows any visitor. You are responsible for how you use the data.

# Actor input Schema

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

One query per line. Separate up to 5 terms with commas to compare them on the same scale, the way Google Trends does.

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

Where the searches come from. Interest by region shows countries for worldwide, states or regions for a country.

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

Shorter ranges come back by hour or day, longer ones by week or month.

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

Only with "Custom range": two dates, YYYY-MM-DD YYYY-MM-DD.

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

Which Google search to measure.

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

Google Trends category, for example 71 Food & Drink or 18 Shopping. 0 = all categories.

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

Add the country / state / region breakdown.

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

Add the top and rising searches for each term, including breakouts (+5000% or more).

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

Two-letter country codes. Each country returns one record with its full Trending now list.

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

The Trending now time window.

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

Leave empty for every category.

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

Most popular first.

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

Google Trends rate-limits busy sessions; 3 is fast and safe.

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

Requests go out directly. This proxy is only used when Google keeps refusing them.

## Actor input object example

```json
{
  "keywords": [
    "pickleball",
    "nike, adidas, puma",
    "chatgpt"
  ],
  "geo": "",
  "timeRange": "today 12-m",
  "customTimeRange": "2024-01-01 2024-06-30",
  "property": "web",
  "category": 0,
  "includeRegions": true,
  "includeRelatedQueries": true,
  "trendingCountries": [
    "US",
    "GB",
    "DE",
    "JP"
  ],
  "trendingHours": "24",
  "maxTrendingPerCountry": 100,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Keyword records: interest over time, summary, interest by region and related searches. Trending records: every trending search with volume, growth, categories and grouped searches.

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

Settings used, records saved and anything that failed, with the reason.

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

// Run the Actor and wait for it to finish
const run = await client.actor("getdataforu/google-trends").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": [
        "pickleball",
        "nike, adidas, puma",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("getdataforu/google-trends").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": [
    "pickleball",
    "nike, adidas, puma"
  ]
}' |
apify call getdataforu/google-trends --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,getdataforu/google-trends"
        }
    }
}
```

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/ZJhIiIJDbrsgEFoki/builds/zV3PaHV6225fG0app/openapi.json