# Google Trends Trending Now — Search Volume, News & Alerts (`signalbench/google-trending-now`) Actor

Live Google Trends 'Trending Now' searches for any country or region: search volume, growth, start/end time, categories, related searches and news articles. Track several countries in one run, or get only new trends on a schedule. No browser, $1 per 1,000 trends, no start fee.

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

## Pricing

$1.00 / 1,000 trends

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 Scraper — Search Volume, News & New-Trend Alerts

Get the live **Google Trends "Trending Now"** list for any country or region: what people are searching for right now, how many searches, how fast it is growing, when it started, its category, the related searches Google groups under it, and the news articles behind it.

- **Several countries in one run.** `US`, `GB`, `DE`, `IN`, `JP`, or regions like `US-CA`.
- **Only new trends.** Run it on a schedule and each run returns only trends you haven't seen yet, so you pay for each trend once. This is built for alerts.
- **News articles included at no extra charge.** Headline, URL, publisher, publish time and image for each trend.
- **Filters:** category (Sports, Politics, Technology…), still-active only, minimum search volume, sort order and a cap per country.
- **$1 per 1,000 trends, and no start fee.** Countries that fail and trends you filter out are never charged.
- **No browser.** It reads the same data the Trending Now page loads, so a run takes seconds.

### Who it's for

- **SEO and content teams** looking for topics to publish on while search demand is rising.
- **Newsrooms and social media managers** who want an alert when a story starts trending in their market.
- **Marketers and agencies** comparing what's hot across several countries.
- **Traders and analysts** who treat search spikes as an early signal.
- **Developers** feeding live trends into dashboards, Slack bots, LLM pipelines or a database.

### What you get

One row per trending search per country:

```json
{
  "trend": "panthers vs packers",
  "geo": "US",
  "rank": 2,
  "isActive": true,
  "startedAt": "2026-10-29T05:30:00.000Z",
  "endedAt": null,
  "trendingForHours": 23,
  "searchVolume": 1000000,
  "searchVolumeLabel": "1M+",
  "increasePercent": 1000,
  "categories": ["Sports"],
  "relatedSearches": ["packers", "packers vs panthers", "panthers", "..."],
  "newsArticles": [
    { "title": "…", "url": "https://www.espn.com/…", "source": "ESPN", "publishedAt": "2026-10-30T03:29:31.000Z", "imageUrl": "https://encrypted-tbn0.gstatic.com/images?q=…" }
  ],
  "exploreUrl": "https://trends.google.com/trends/explore?q=panthers%20vs%20packers&geo=US&date=now%201-d",
  "windowHours": 24,
  "scrapedAt": "2026-10-30T04:30:00.000Z"
}
```

| Field | Meaning |
| --- | --- |
| `trend` | The trending search, as Google shows it (in the country's own language). |
| `rank` | Position on Google's Trending Now page for that country (1 = top). |
| `searchVolume` / `searchVolumeLabel` | Searches in the window, as Google's bucket: `5000000` / `5M+` means at least 5 million. |
| `increasePercent` | Growth over the usual volume, in percent. Google tops out at 1000 (shown as 1,000% on the page). |
| `isActive`, `startedAt`, `endedAt`, `trendingForHours` | Whether it is still trending, and for how long. |
| `categories` | Google's Trending Now categories. A trend can have several. |
| `relatedSearches` | The searches Google groups under the trend (its "trend breakdown"). |
| `newsArticles` | Only when **Include news articles** is on. |
| `exploreUrl` | The Google Trends chart for the trend. |

Export as JSON, CSV, Excel or HTML, or read it through the API.

### Quick start

**Top 25 trends in the US right now:** in the Console, the input is already filled in with US and a cap of 25. Click **Start**. (Through the API, an empty input returns the whole US list.)

**Today's top sports and politics trends in three countries, with news:**

```json
{
  "geos": ["US", "GB", "CA"],
  "timeWindow": "24",
  "categories": ["17", "14"],
  "sortBy": "searchVolume",
  "maxItemsPerGeo": 20,
  "includeNews": true,
  "newsPerTrend": 3
}
```

### Get alerts for new trends (scheduled monitoring)

1. Turn on **Only new trends since the last run** and give the run a **Monitor ID**, for example `us-all`.
2. Save the input as a **task**, then add a **schedule** to it in the Console, for example every hour.
3. Connect an integration to the task: Slack, email, Google Sheets, Zapier, Make or a webhook. Each run sends only the trends that appeared since the previous run.

The first run returns everything currently trending that passes your filters. After that you only see, and only pay for, what's new. With **Max trends per country** set, the cap is the most alerts you get per run: trends past the cap are marked as seen and skipped, so a busy hour never leaves you working through a backlog of older trends. Use **Sort by: Newest first** if the cap should keep the freshest ones. Each Monitor ID keeps its own list, so give tasks with different filters different IDs, and don't let two runs with the same ID overlap. A trend that stays on Google's list is never returned twice. The list is kept in a key-value store named `google-trending-now-seen` in your own account, and it's saved as each country finishes, so a run that's aborted partway doesn't make the next run bill those trends again.

### Input

| Option | Default | Notes |
| --- | --- | --- |
| Countries / regions | `["US"]` | Two-letter codes (`US`, `GB`, `DE`, `IN`, `BR`, `JP`…) or regions (`US-CA`, `GB-ENG`). |
| Time window | Past 24 hours | Past 4 hours, 24 hours, 48 hours or 7 days, the windows Google offers. |
| Categories | all | Autos and Vehicles, Beauty and Fashion, Business and Finance, Climate, Entertainment, Food and Drink, Games, Health, Hobbies and Leisure, Jobs and Education, Law and Government, Other, Pets and Animals, Politics, Science, Shopping, Sports, Technology, Travel and Transportation. |
| Only trends that are still active | off | Skip trends Google marks as ended. |
| Minimum search volume | 0 | Use a bucket value: 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000… |
| Max trends per country | 0 (all) | A large country has 300–500 trends in 24 hours and several thousand over 7 days. |
| Sort by | Google's order | Or search volume, or newest first. Applied before the cap. |
| Include news articles / Articles per trend | off / 3 | Up to 10 articles per trend. |
| Only new trends / Monitor ID | off / `default` | See the monitoring section. |
| Language | `en-US` | Language of Google's response. Affects news and some labels. |
| Proxy | off | Off: the Actor connects directly and switches to Apify residential proxies by itself if Google blocks it. |

### Pricing

**$0.001 per trend stored ($1 per 1,000). No start fee.** You don't pay for countries that fail, trends removed by your filters, or trends already seen in only-new mode. News articles are included at no extra charge.

Examples:

- Top 25 trends in one country: **$0.025**.
- The full 24-hour US list (about 450–500 trends): **about $0.50**.
- US every hour with **Only new trends**: you pay for each trend once, so about one full 24-hour list per day, **roughly $0.30–$0.50 a day**.

Set a **maximum charge per run** in the run options. The Actor stops cleanly at that limit and tells you which countries it didn't fetch.

### Need more than today's trends?

Trending Now shows what is spiking at the moment. To see a keyword's **interest over time** (back to 2004), **interest by region**, or **related queries and topics**, pass the trends you find here to the [Google Trends Scraper](https://apify.com/signalbench/google-trends-scraper). Each row's `exploreUrl` also opens the trend in Google Trends.

### FAQ

**How fresh is the data?** Each run fetches the live Trending Now list, the same one trends.google.com/trending shows at that moment.

**Which countries are supported?** Every country and region Google's Trending Now page offers. A code that's unsupported or mistyped (like `USA`) is skipped, reported in the run's status message and not charged; the other countries in the run still go through.

**Why is search volume a round number?** Google only publishes volume in buckets (`2K+`, `50K+`, `1M+`). `searchVolume` is the bucket's lower bound.

**Why do trends appear in several countries?** Big stories trend everywhere. Each country's row has its own rank, volume and timing.

**Is this an official Google API?** No. Google doesn't offer a Trending Now API. This Actor reads the same public data the Trending Now page shows.

### Feedback and reviews

Missing a field or a country? Open an issue on the [Issues tab](https://apify.com/signalbench/google-trending-now/issues) and I'll take a look. If the Actor saves you time, a quick review on the [Reviews tab](https://apify.com/signalbench/google-trending-now/reviews) helps other people find it.

# Actor input Schema

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

Two-letter country codes (US, GB, DE, IN, JP…) or sub-regions (US-CA, GB-ENG). One row each; every one is fetched in the same run.

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

How far back the Trending Now list goes. These are the four windows Google offers.

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

Keep only trends in these categories. Leave empty for all categories.

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

Skip trends Google marks as ended.

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

Skip trends below this volume. Google reports volume in buckets (100+, 200+, 500+, 1K+, 2K+, 5K+, 10K+, 20K+, 50K+, 100K+, 200K+, 500K+, 1M+…), so use one of those.

## `maxItemsPerGeo` (type: `integer`):

Cap on trends stored per country/region after filters and sorting. 0 = all of them (a large country has 300–500 per 24 hours). With 'Only new trends', this is the most alerts per run: trends past the cap are marked seen and skipped.

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

Order of trends within each country. Applied before the per-country cap, so it decides which trends you keep.

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

Add the news articles Google shows for each trend (title, URL, source, publish time, image). No extra charge; adds about a second per 8 trends.

## `newsPerTrend` (type: `integer`):

How many articles to attach to each trend (1–10).

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

For scheduled runs: skip trends this monitor already returned in an earlier run, so each run gives (and bills) only what is new. The list is kept in a named key-value store in your account (google-trending-now-seen). Don't run two schedules with the same Monitor ID at the same time.

## `monitorId` (type: `string`):

Only used with 'Only new trends'. Give each scheduled task its own ID (e.g. us-sports) so tasks with different filters keep separate seen-lists.

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

Language for Google's response, e.g. en-US, de, ja. Affects news and some labels; trend keywords are in the country's own language.

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

Leave off: the Actor connects directly and switches to Apify residential proxies by itself if Google blocks it. Turn on to use a proxy from the first request.

## Actor input object example

```json
{
  "geos": [
    "US"
  ],
  "timeWindow": "24",
  "categories": [],
  "activeOnly": false,
  "minSearchVolume": 0,
  "maxItemsPerGeo": 25,
  "sortBy": "relevance",
  "includeNews": false,
  "newsPerTrend": 3,
  "onlyNew": false,
  "monitorId": "default",
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All trends in JSON.

## `resultsCsv` (type: `string`):

All trends as CSV.

## `viewInConsole` (type: `string`):

Open the run in the Apify Console.

# 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"
    ],
    "maxItemsPerGeo": 25,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalbench/google-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 = {
    "geos": ["US"],
    "maxItemsPerGeo": 25,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("signalbench/google-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 '{
  "geos": [
    "US"
  ],
  "maxItemsPerGeo": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call signalbench/google-trending-now --silent --output-dataset

```

## MCP server setup

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