# Google Trends Trending Now Monitor - Full List & New Alerts (`zahidthani/google-trends-trending-now`) Actor

Get every Google Trends 'Trending Now' search for any country (hundreds, not just the top 10): search volume, % increase, start/end time, categories, related queries and news. Filter by category or volume, and schedule it in 'only new' mode to get just the trends that appeared since the last run.

- **URL**: https://apify.com/zahidthani/google-trends-trending-now.md
- **Developed by:** [Zahid Thani](https://apify.com/zahidthani) (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 $1.00 / 1,000 trending searches

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 Monitor - Full List & New Alerts

**Get every trending search on Google right now for any country, the same list you see on
[trends.google.com/trending](https://trends.google.com/trending), as clean JSON, CSV or Excel: search volume,
% increase, start and end time, categories and related searches. Schedule it in "only new" mode and it becomes a
trend alert system. $1 per 1,000 trends.**

### What can this Google Trends Trending Now scraper do?

- 🔥 **The full list, not the RSS top 10.** Most tools read Google's RSS feed, which has about **10 trends**. This
  Actor returns every trend on the Trending Now page, **often 300-500 per country per day**, for the past 4h, 24h,
  48h or 7 days.
- 📊 **Rich fields**: search volume (`200000`) and label (`200K+`), % increase, start/end time, active flag,
  duration, categories, related searches, a Google Trends explore link, and how many news articles Google links.
- 🔔 **Only-new monitor mode.** `onlyNew` remembers what you already received (per monitor name), so scheduled runs
  never repeat a trend and **you're never charged twice for the same one**.
- 🎯 **Filters that save money**: category (Sports, Technology, Business...), minimum search volume, active-only and a
  keyword filter are applied **before** billing. You only pay for trends you receive.
- 🌍 **Many countries in one run**: `["US", "GB", "DE", "IN", "BR"]`, about 125 countries supported.
- 🛡️ **Reliable**: automatic retries with a fresh IP, plus residential proxy fallback when Google pushes back.

### Who uses it

- **Newsrooms and content teams:** catch breaking stories the moment search interest spikes.
- **SEO and social media:** find topics to write or post about while they're still rising (`activeOnly`, `sortBy: newest`).
- **E-commerce and marketing:** watch for trends in your category (`categories: ["Shopping", "Beauty and Fashion"]`).
- **Traders and analysts:** monitor company, product or crypto names with `keywordFilter` and get alerted on spikes.
- **AI agents and dashboards:** call it from the API or MCP and get structured trend data with no parsing.

### How to use it

1. Click **Try for free**. The form opens with the US and a limit of 50 trends.
2. Pick countries, a time window and, optionally, categories or a minimum search volume.
3. Click **Start**. A country takes about 5 seconds.
4. For alerts: turn on **Only new trends**, give the monitor a name, save it as a task and add a schedule
   (e.g. every hour). Connect Slack, email, Google Sheets or a webhook to the task.

### Input examples

**Today's top 50 trends in the US (the default)**

```json
{ "countries": ["US"], "maxItemsPerCountry": 50 }
```

**Hourly tech and business alert for the US and UK**

```json
{
  "countries": ["US", "GB"],
  "timeWindow": "4",
  "categories": ["Technology", "Business and Finance"],
  "minSearchVolume": 2000,
  "onlyNew": true,
  "monitorName": "tech-alerts",
  "maxItemsPerCountry": 0
}
```

| Field | What it does |
|---|---|
| `countries` | Country codes: `US`, `GB`, `DE`, `IN`, `JP`... (default `US`) |
| `timeWindow` | `4`, `24`, `48` or `168` hours, the same as the "Since" filter on Google |
| `categories` | Only these categories, e.g. `["Sports", "Technology"]` (empty = all) |
| `minSearchVolume` | Skip trends with fewer searches, e.g. `10000` |
| `activeOnly` | Only trends that are still rising |
| `keywordFilter` | Only trends whose search or related searches contain this text |
| `sortBy` | `rank` (Google's order), `volume` or `newest` |
| `maxItemsPerCountry` | Limit per country after filters (default 25, `0` = all) |
| `onlyNew` + `monitorName` | Monitor mode: deliver only trends not delivered by earlier runs of this monitor |
| `includeNews` | Attach news links and a picture where Google's news feed has them (free) |

### Output example

A real item from a run on 6 October 2026 (US, past 24 hours). That run found 418 trends and delivered the top 50:

```json
{
  "type": "trend",
  "geo": "US",
  "rank": 2,
  "keyword": "dodgers vs braves",
  "searchVolume": 200000,
  "searchVolumeLabel": "200K+",
  "increasePercent": 1000,
  "startedAt": "2026-10-06T21:00:00Z",
  "endedAt": null,
  "isActive": true,
  "durationHours": 3.5,
  "categories": ["Sports"],
  "relatedQueries": ["dodgers game", "braves game", "where to watch dodgers vs atlanta braves", "matt olson", "dodgers vs braves prediction", "lad vs atl"],
  "newsArticleCount": 24,
  "news": [],
  "picture": null,
  "trendsExploreUrl": "https://trends.google.com/trends/explore?q=dodgers+vs+braves&geo=US&date=now+7-d",
  "scrapedAt": "2026-10-07T00:32:42Z",
  "timeWindowHours": 24
}
```

`newsArticleCount` is filled for every trend. Full news links (`news`: title, URL, source) and a `picture` come from
Google's news feed, which covers only about 10 trends per country at a time, so most items have `news: []`.
The run summary (trends found per country, skipped as already seen, failures) is saved as `OUTPUT` in the
key-value store.

### How much does it cost?

| Event | Price | Per 1,000 |
|---|---|---|
| Trend delivered | $0.001 | **$1.00** |
| Run start | $0.005 | - |

| Job | Cost |
|---|---|
| Daily snapshot of the top 50 US trends | about $0.055 |
| Every US trend of the day (about 400) | about $0.41 |
| Hourly only-new monitor, one country, filtered | usually $0.15-0.30 a day including run fees |

Filtered-out, already-seen and failed trends are never charged. Set **Maximum cost per run** and the Actor stops
cleanly when it's reached.

### Use it with AI agents (MCP) and the API

Connect it to Claude, ChatGPT, Cursor or any MCP client via
`https://mcp.apify.com?tools=zahidthani/google-trends-trending-now` and ask, for example:

> What's trending on Google in the US and UK right now in Technology? Only trends over 10K searches, sorted by volume.

```bash
curl -X POST "https://api.apify.com/v2/acts/zahidthani~google-trends-trending-now/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"countries": ["US"], "categories": ["Technology"], "minSearchVolume": 10000, "sortBy": "volume"}'
```

### How it compares

| | This Actor | RSS-based Trending Now scrapers | Manual trends.google.com |
|---|---|---|---|
| Trends per country | Full list (hundreds) | About 10 | Full list, by hand |
| Search volume and % increase | Yes | Approximate traffic only | Yes |
| Start/end time, active flag | Yes | Start only | Yes |
| Categories and related searches | Yes | No | Yes |
| Only-new monitor mode (no repeats, no double charges) | Yes | No | No |
| Filters before billing | Yes | No | n/a |
| Several countries in one run | Yes | Usually one | One at a time |

### FAQ

**Is there a Google Trends API for trending searches?** Google doesn't offer an open API for the Trending Now list.
This Actor turns the public page into an API: call it from any language, a no-code tool or an AI agent.

**How does "Only new trends" work?** The Actor stores the trends it delivered in a key-value store in your Apify
account (`trending-now-monitor`, one record per monitor name, kept for 10 days). The next run skips anything
already delivered. A trend that ends and later trends again counts as new. Use different `monitorName`s for
monitors with different filters.

**How do I get alerts in Slack or email?** Schedule the Actor (Apify Console > Schedules, e.g. every hour), turn
on `onlyNew`, and add an integration (Slack, email, Google Sheets, Zapier, Make or a webhook) to the task.

**Which countries are supported?** Every country available on trends.google.com/trending (about 125). Use
two-letter codes. An unsupported code is reported as failed and isn't charged.

**What is `searchVolume`?** Google's rounded estimate of searches since the trend started (e.g. 2000, 50000, 500000).
`increasePercent` is how much searches grew compared with before the trend.

**How often does the list update?** Google refreshes Trending Now continuously. An hourly schedule catches new
trends within the hour.

**Is it legal?** The Actor collects only **public, aggregated** trend data that anyone can see on
trends.google.com, with no login or Google account. It collects no personal data.

**Need interest over time, by region or related queries for a trend?** Use our
[Google Trends Scraper](https://apify.com/zahidthani/google-trends-scraper): spot a trend here, then analyse it there.

Found a bug or want a feature? Open an issue on the **Issues** tab. We usually respond within a day.

### Related Actors

- [Google Trends Scraper](https://apify.com/zahidthani/google-trends-scraper): interest over time, by region and related queries for any keyword.
- [App Store & Google Play Reviews Scraper](https://apify.com/zahidthani/app-store-google-play-reviews): what users say about any app, in both stores.
- [Website Tech Stack Detector](https://apify.com/zahidthani/website-tech-stack-detector): the technologies behind any list of websites.

# Actor input Schema

## `countries` (type: `array`):

Two-letter country codes to monitor (US, GB, DE, IN, BR, JP...). Each country is fetched separately; about 125 countries are supported by Google Trends.

## `timeWindow` (type: `string`):

Which trends to include, by when they started. Same choices as the 'Since' filter on trends.google.com/trending.

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

Only return trends in these Google Trends categories (e.g. Sports, Technology, Business and Finance). Leave empty for all categories.

## `minSearchVolume` (type: `integer`):

Skip trends with fewer searches than this (Google's estimate, e.g. 2000, 10000, 100000). 0 keeps everything.

## `activeOnly` (type: `boolean`):

Only return trends that are still rising right now (Google marks the rest as ended).

## `keywordFilter` (type: `string`):

Only return trends whose search or related searches contain this text, e.g. 'iphone' or 'election'. Case-insensitive.

## `sortBy` (type: `string`):

Order of results within each country. Applied before the per-country limit, so 'Search volume' + a limit of 20 gives the 20 biggest trends.

## `maxItemsPerCountry` (type: `integer`):

Stop after this many trends per country (after filters). 0 = no limit (a busy country has 300-500 trends per day). You pay per trend delivered.

## `onlyNew` (type: `boolean`):

Remember what earlier runs returned and deliver only trends that weren't delivered before. Perfect for a schedule (e.g. every hour) feeding Slack, email or a sheet. Already-seen trends are not charged.

## `monitorName` (type: `string`):

Used with 'Only new trends'. Each name keeps its own memory, so you can run separate monitors (e.g. 'us-tech' and 'uk-sports') without them hiding each other's trends.

## `includeNews` (type: `boolean`):

Attach news articles (title, URL, source) and a picture to trends that Google's news feed covers (usually the freshest top trends). Costs nothing extra.

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

Interface language used for the request, e.g. en-US, de, fr, ja. Trend titles stay in the language people searched in.

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

Apify Proxy is recommended. Datacenter proxies are used first; the Actor rotates IPs automatically when Google slows down.

## `allowResidentialFallback` (type: `boolean`):

If Google keeps refusing requests from datacenter IPs, switch to residential proxies (when your plan includes them) so the run still succeeds.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "timeWindow": "24",
  "minSearchVolume": 0,
  "activeOnly": false,
  "sortBy": "rank",
  "maxItemsPerCountry": 50,
  "onlyNew": false,
  "monitorName": "default",
  "includeNews": true,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "allowResidentialFallback": true
}
```

# Actor output Schema

## `results` (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 = {
    "countries": [
        "US"
    ],
    "maxItemsPerCountry": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zahidthani/google-trends-trending-now").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 = {
    "countries": ["US"],
    "maxItemsPerCountry": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zahidthani/google-trends-trending-now").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 '{
  "countries": [
    "US"
  ],
  "maxItemsPerCountry": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zahidthani/google-trends-trending-now --silent --output-dataset

```

## MCP server setup

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

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/jaxjMR1ZcywLKDR0k/builds/88QfeKU0rew9opqHj/openapi.json