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

Scrape trending Google searches by country with search volume, growth, category and the related queries people search alongside each trend.

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

## Pricing

from $0.50 / 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Trends Scraper

Returns the searches that are **rising right now** in any country — with how many
people searched, how fast it grew, what category it belongs to, and **the queries
people search alongside it**.

One request per country returns the whole list. Not a sample, not a top ten:

| Country | Window | Trends returned |
|---|---|---:|
| United States | 24 hours | **526** |
| Argentina | 24 hours | 154 |
| United Kingdom | 4 hours | 97 |
| Spain | 7 days | **1,762** |

### What you actually get

A spike dies in hours. The cluster of searches around it does not — that is what
you write, bid or rank against:

```json
{
  "term": "jed york",
  "volume": 200000,
  "growthPercent": 1000,
  "startedAt": "2026-08-24T14:40:00.000Z",
  "categories": ["Law and Government"],
  "relatedQueries": [
    "49ers owner", "jed york arrested", "jed york wife",
    "danielle belluomini", "san francisco 49ers", "49ers news",
    "east palestine ohio", "nfl news"
  ],
  "window": "24h",
  "rank": 1
}
```

Sixteen related queries for one trend, and up to 57 on some. That is keyword
research that is hours old, not a monthly export.

### Input

```json
{ "geos": ["US", "GB", "AR"], "window": "24h" }
```

Only the sports stories that actually moved, with their query clusters:

```json
{
  "geos": ["ES", "AR", "MX"],
  "window": "48h",
  "categories": ["Sports"],
  "minVolume": 20000,
  "onlyWithRelatedQueries": true
}
```

| Parameter | Type | Default | What it does |
|---|---|---|---|
| `geos` | array | `["US"]` | Two-letter country codes. One request each. |
| `window` | string | `"24h"` | `4h`, `24h`, `48h` or `7d`. A wider window returns far more terms — roughly 100 at 4 hours against 1,700 at 7 days for the same country. |
| `categories` | array | — | By name: `Sports`, `Politics`, `Entertainment`, `Business and Finance`, `Technology`, and the rest. A name Google does not publish stops the run and prints the valid list, instead of silently returning nothing. |
| `minVolume` | integer | — | Drops the long tail. `20000` leaves what actually moved. |
| `onlyWithRelatedQueries` | boolean | `false` | Keeps only the trends that carry a query cluster. |
| `keywords` | array | — | Keep trends whose term or related queries match — how you watch a brand across countries. |
| `maxItems` | integer | `500` | Hard cap on rows saved and charged. `0` means no cap. |
| `includeSeen` | boolean | `true` | Set to `false` to save only trends never returned before. Built for scheduled runs. |

### Output

| Field | Notes |
|---|---|
| `term` | The search as people type it. |
| `volume` | Estimated searches. Google publishes these rounded. |
| `growthPercent` | Growth against the previous period. Google caps it at 1000, which means "over 1000%", not exactly 1000. |
| `startedAt` | When it began rising. |
| `relatedQueries` | What people search around the term, strongest first. Google publishes these for roughly one trend in five — the rest come back as an empty list rather than a guess. |
| `categories` | Names, not numbers. Read from the page's own filter list, so a rename by Google shows up as the new name instead of breaking. |
| `window` | The window the row was requested with. Volume is not comparable across windows, so it travels with the row. |
| `rank` | Position within that country and window. |

### Tracking trends over time

Set `includeSeen` to `false` and schedule the Actor. Each run then saves only
terms it has never returned, so the dataset becomes a clean timeline of what
started trending rather than the same list repeated every hour.

### Cost

**No proxy.** Google Trends serves this to an ordinary client, verified across
four countries and three windows. That makes this the cheapest Actor we publish —
one request covers a whole country, and residential bandwidth, which is the
dominant cost everywhere else, is zero here.

Empty and duplicate rows are never charged.

### Notes

The list is read from the state Google ships to fill its own trends table, not
from the page markup — that is why obfuscated class names being regenerated on
every deploy does not affect this Actor.

Two endpoints that every public guide still recommends, `/trends/api/dailytrends`
and `/trends/api/explore`, no longer respond. Both were tried and both failed;
this page is what remains.

Google accepts `?category=` in the URL but ignores it — the response is identical
with and without it. Category filtering here happens on the extracted rows, which
is why it works.

# Actor input Schema

## `geos` (type: `array`):

Two-letter country codes, one per country you want. US, AR, ES, GB, IN, BR. Each country is a single request that returns its whole trending list.

## `window` (type: `string`):

How far back to look. A wider window returns far more terms: the same country goes from about 100 trends over 4 hours to roughly 1,700 over 7 days.

## `categories` (type: `array`):

Keep only trends in these categories, by name: Sports, Politics, Entertainment, Business and Finance, Technology, Health, Games, Travel and Transportation, Climate, and others. A name Google does not publish stops the run with the valid list, rather than silently returning nothing.

## `minVolume` (type: `integer`):

Keep only trends with at least this many estimated searches. 20000 drops the long tail and leaves what actually moved. Trends with no volume are dropped, because they cannot be said to clear a minimum.

## `onlyWithRelatedQueries` (type: `boolean`):

Google publishes the surrounding queries for roughly one trend in five. Turn this on when you want the ones you can actually build keyword research from.

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

Keep only trends whose term or related queries contain one of these. This is how you watch a brand or a topic across countries.

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

Hard cap on how many trends are saved and charged. 0 means no cap.

## `includeSeen` (type: `boolean`):

Off means the run only saves trends it has never returned before, which is what you want when running this on a schedule.

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

Parallel requests, one per country.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried before that country is given up on.

## `maxRequestsPerMinute` (type: `integer`):

Rate limit for the whole run.

## Actor input object example

```json
{
  "geos": [
    "US"
  ],
  "window": "24h",
  "onlyWithRelatedQueries": false,
  "maxItems": 500,
  "includeSeen": true,
  "maxConcurrency": 2,
  "maxRequestRetries": 3,
  "maxRequestsPerMinute": 30
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "geos": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("juanoox/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 = { "geos": ["US"] }

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

```

## MCP server setup

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