# Google Trends — Daily Trending Searches & Breakout Searches (`drlipton/google-trends-fast-scraper`) Actor

Daily trending searches and breakout searches from Google Trends Trending Now, by country, with search volume, growth percent, related queries, and news links. Real-time trending searches in one HTTP run. Interest over time is a second mode.

- **URL**: https://apify.com/drlipton/google-trends-fast-scraper.md
- **Developed by:** [Joel Smith](https://apify.com/drlipton) (community)
- **Categories:** Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 trend or keyword scrapeds

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 Trending Now — Daily Trending Searches & Breakout Searches

Pull **today's daily trending searches and breakout searches** for one country: search volume bucket (`200,000+`), growth percent, related queries, and news links. Real-time trending searches in one HTTP run, no browser. Interest over time is a second mode.

**$2.00 per 1,000 items** (`trend-query-scraped` at $0.002). Ten US breakouts cost $0.02. You are not charged when Google rate-limits a keyword explore.

Use this Actor when you need:

- a morning list of breakout searches for SEO, newsletters, or content calendars
- search-volume buckets and growth percent, not just the keyword text
- related queries and news links attached to each trend
- a daily schedule (`mode: "trending_now"`, `geo: "US"`) into Slack, n8n, or an agent

Keyword interest-over-time is available as `mode: "explore"`. The default run does not use it.

[![Run on Apify](https://apify.com/ext/run-on-apify-button)](https://apify.com/drlipton/google-trends-fast-scraper)

### Start here

Leave the example input and click Start.

```json
{
  "mode": "trending_now",
  "geo": "US",
  "maxItems": 10
}
```

Open the dataset view **Daily breakout searches**. You should see `keyword`, `approxTraffic`, `growthPct`, and `trendDirection`. Related queries and news links are on each item (`relatedQueries`, `newsItems`).

### Pricing

| | |
|---|---|
| Event | `trend-query-scraped` |
| Price | **$0.002 per item** ($2.00 / 1,000) |
| Charged when | A trending topic is returned, or an explore keyword whose interest-over-time data actually came back |
| Not charged | Explore keywords where Google returns HTTP 429 on the timeseries widget |
| Compute | 256 MB. A trending run is one short HTTP call |

### Real-time trending searches by country

`mode: "trending_now"` is the default. It returns today's breakout searches for one `geo` from Google's trending page data and the trending RSS feed. One HTTP run, proxy off. Fields include `searchVolume`, `approxTraffic`, `growthPct`, `categoryIds`, and `startTime`. Schedule it every morning with a country code.

### Related queries and news

Each trending row includes `relatedQueries` (the breakout cluster behind the headline search) and `newsItems` with `title`, `url`, and `source`. Those are the fields to drop into Slack, a newsletter, or a content calendar.

### Interest over time

`mode: "explore"` returns interest over time, interest by region, and related topics for the `keywords` you name. Turn proxy on (`useApifyProxy: true`). If Google returns HTTP 429 on the timeseries, that keyword is not billed. If every keyword is rate-limited, the run fails and the charge is zero.

```json
{
  "mode": "explore",
  "keywords": ["klarna", "spotify"],
  "geo": "US",
  "timeRange": "today 12-m",
  "maxItems": 2,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Real output item (`trending_now`)

```json
{
  "recordType": "trending_now",
  "rank": 1,
  "keyword": "champions league",
  "geo": "US",
  "searchVolume": 200000,
  "approxTraffic": "200,000+",
  "growthPct": 1000,
  "trendDirection": "BREAKOUT",
  "startTime": "2026-10-20T17:10:00+00:00",
  "endTime": null,
  "categoryIds": [17],
  "relatedQueries": [
    { "query": "psg vs barcelona", "source": "trends_breakout_cluster" },
    { "query": "uefa champions league", "source": "trends_breakout_cluster" }
  ],
  "newsItems": [
    {
      "title": "Champions League: PSG vs Barcelona - Europe's most exciting match-up?",
      "url": "https://www.bbc.com/sport/football/articles/c820vw7velvro",
      "source": "BBC"
    }
  ]
}
```

### Call it from code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("drlipton/google-trends-fast-scraper").call(
    run_input={"mode": "trending_now", "geo": "US", "maxItems": 10},
    max_total_charge_usd=0.05,
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

JavaScript:

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<APIFY_TOKEN>" });
const run = await client.actor("drlipton/google-trends-fast-scraper").call(
  { mode: "trending_now", geo: "US", maxItems: 10 },
  { maxTotalChargeUsd: 0.05 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Schedule: in Apify Console, create a schedule for this Actor every day at 07:00 with the input above. Point the run's dataset at Slack, email, or n8n.

MCP: point the client at `https://mcp.apify.com` with your Apify token and ask for `drlipton/google-trends-fast-scraper`. Pass `geo`. Leave `mode` as `trending_now`.

n8n: import `distribution/examples/n8n_daily_trends_slack.json` (Import from File). It runs every day at 07:00 and posts `keyword`, `approxTraffic`, and `growthPct` to Slack. Or use the Apify node, **Run actor and get dataset items**, actor `drlipton/google-trends-fast-scraper`, input as in the sample.

### FAQ

**Why not start in explore mode?** Google rate-limits interest-over-time from datacenter IPs. Trending Now is the run that completes on the first click.

**Is the volume an exact count?** No. Google publishes a bucket such as `200,000+`. Both the label (`approxTraffic`) and the bucket floor (`searchVolume`) are returned.

**What if explore is rate-limited?** That keyword is skipped and not billed. The run fails only when every requested keyword was rate-limited, and then the charge is still zero.

### Related Actors

- [Google Ads Transparency — landing page UTMs, MP4s, and EU DSA reach](https://apify.com/drlipton/google-ads-transparency-scraper)
- [Google Play and App Store reviews — developer replies](https://apify.com/drlipton/google-play-reviews-scraper)

# Actor input Schema

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

Use 'trending_now' for daily breakout searches (volume, growth, related queries, news). Use 'explore' only when you need interest-over-time for specific keywords. The first run should stay on trending_now.

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

Two-letter country code (e.g. 'US', 'SE', 'GB', 'DE'). Empty string is worldwide.

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

How many breakout topics (trending_now) or keywords (explore) to return. 10 trending topics is a complete daily sample ($0.02).

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

Search terms for explore mode only. Ignored by Trending Now. Example: klarna, spotify.

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

Google Trends time window for explore mode: 'now 1-d', 'now 7-d', 'today 1-m', 'today 3-m', 'today 12-m', 'today 5-y', or 'all'.

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

Google Trends category ID (0 = All categories, 5 = Computers & Electronics, 7 = Finance, 12 = Business & Industrial).

## `hl` (type: `string`):

Language code for explore results (e.g. 'en-US', 'sv-SE', 'de-DE').

## `tz` (type: `integer`):

Timezone offset in minutes passed to Google Trends (0 = UTC, -120 = CEST, 240 = EDT).

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

Explore mode only. Fetch historical timeline data points and summary statistics (mean, peak, latest, momentum). You are not charged if Google returns HTTP 429 for this widget.

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

Explore mode only. Fetch geographic breakdown across states/sub-regions or countries.

## `includeRelated` (type: `boolean`):

Explore mode only. Fetch related queries and Knowledge Graph topic entities.

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

Leave off for Trending Now. Turn on for explore mode so Google is less likely to return HTTP 429 on the TIMESERIES widget.

## Actor input object example

```json
{
  "mode": "trending_now",
  "geo": "US",
  "maxItems": 10,
  "timeRange": "today 12-m",
  "category": 0,
  "hl": "en-US",
  "tz": 0,
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeRelated": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "mode": "trending_now",
    "geo": "US",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("drlipton/google-trends-fast-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 = {
    "mode": "trending_now",
    "geo": "US",
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,drlipton/google-trends-fast-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/hM0Y9kLIc7I3xk0OF/builds/FZIxzzpBSj8cHgFSw/openapi.json