# Google Trends Trending Now - Daily Trending Searches (`neverempty/google-trends-trending-now`) Actor

Trending Now searches from Google Trends for any country or US state: term, approx. search volume, time listed, image and linked news. Watch mode returns only trends not seen before, for alerts. No login, no browser.

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

## Pricing

from $0.25 / 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.
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 Trending Now - Daily Trending Searches

Get the **Trending Now** list from Google Trends for any country or US state: what people are searching for right now, with the approximate search volume, the time Google lists for each trend, an image and the news articles Google links to it. One clean row per trending search. Built for newsrooms, content and SEO teams, social media managers, traders and AI agents that want to know what is trending before everyone else.

- **Many countries in one run.** Give `US`, `GB`, `DE`, `JP`, `IN`, `BR`... or a region such as `US-CA`. Each country is one request.
- **Watch mode for alerts.** With `onlyNew`, scheduled runs return only trending searches this watch has not returned before for that country. Run it every 15 minutes or every hour and send new rows to Slack, email or a webhook with an Apify integration.
- **Search volume as a number.** Google shows `"2000+"`; you also get `approxTrafficMin: 2000`, so you can sort, filter and set alerts. `minSearchVolume` keeps only the bigger trends.
- **Linked news included.** Each row carries the news items Google attaches to the trend (title, URL, source, image).
- **Nothing is guessed.** A value Google does not give is `null`, never `0` or `""`. A country code Google does not accept, an empty list or a run that hit its charge limit comes back as a free row that says why.
- **No login, no browser.** Reads Google Trends' public Trending Now RSS feed.

Unofficial. Not affiliated with Google.

### What you get

One row per trending search:

| Field | Example | Meaning |
|---|---|---|
| `geo` | `US` | The country or region code you asked for |
| `countryName` | `United States` | English name of the country part of the code |
| `listPosition` | `1` | Position in Google's list. The feed lists the most recently started trends first; it is **not** a volume ranking |
| `searchTerm` | `netflix movies` | The trending search |
| `approxTraffic` | `10000+` | Approximate search volume exactly as Google shows it |
| `approxTrafficMin` | `10000` | The same as a number (the lower bound) |
| `publishedAt` | `2026-10-03T09:50:00.000Z` | The time Google gives for this trend in the feed (pubDate), in UTC |
| `picture`, `pictureSource` | image URL, `Live 5 News` | The image Google shows for the trend and where it is from |
| `newsCount`, `news` | `3`, `[{title, url, source, picture, snippet}]` | News articles Google links to the trend |
| `exploreUrl` | Google Trends link | Opens this term in Google Trends for the past day in that country |
| `trendingPageUrl` | Google Trends link | The Trending Now page for that country |
| `changeType` | `first-check` / `new` | Watch mode only; `null` otherwise |
| `checkedAt` | ISO time | When this run read the list |

Example row (US, 2026-10-03):

```json
{
  "status": "ok",
  "geo": "US",
  "countryName": "United States",
  "listPosition": 4,
  "searchTerm": "netflix movies",
  "approxTraffic": "10000+",
  "approxTrafficMin": 10000,
  "publishedAt": "2026-10-03T09:30:00.000Z",
  "newsCount": 3,
  "news": [{ "title": "...", "url": "https://...", "source": "...", "picture": "https://...", "snippet": null }]
}
```

Google's feed has about 10 trending searches per country at a time.

#### Free rows (not charged)

| `status` | When |
|---|---|
| `unknown-country` | Google does not accept the code (for example `UK`; Google uses `GB`) |
| `bad-input` | The value is not a country code, or watch mode was started without a country |
| `no-trends` | Google answered with an empty list for that country |
| `no-new-trends` | Watch mode: nothing in the list that this watch has not returned before |
| `below-minimum` | Every search in the list is below your `minSearchVolume` |
| `blocked`, `unreadable` | Google refused or sent something that is not the feed, after retries from other IP addresses |
| `timed-out` | The run was about to reach its timeout, so that country was not read |
| `budget-reached` | The run reached its maximum total charge; the row lists what was not returned |

If no list could be read for any country (codes not accepted, input not usable, blocked, unreadable or timed out), the run is not charged and ends with an error so your schedule notices.

### Input

| Field | Default | Notes |
|---|---|---|
| `countries` | empty = `US` (watch mode needs at least one) | Country codes such as `US`, `GB`, `JP`, or regions such as `US-CA`, up to 150 per run. Lower case is accepted. Duplicates are read once |
| `minSearchVolume` | empty | Keep only searches with `approxTrafficMin` at least this number |
| `onlyNew` | off | Watch mode (below) |
| `watchName` | empty | Separate memory for separate schedules |
| `resetMonitoringState` | off | Forget the watch memory at the start of this run |

### Watch mode

1. Run once with `onlyNew: true` and your countries: the whole list of each country comes back with `changeType: "first-check"` (if the run hits its maximum total charge first, the rest of that first list comes back as `first-check` in the next run).
2. Create a **Schedule** with the same input (for example every 30 minutes).
3. Later runs return only searches this watch has not returned before for that country (`changeType: "new"`). A country with nothing new is one free `no-new-trends` row.

A search that leaves the list and is not seen for 7 days is forgotten, so it comes back as new if it trends again. Searches below `minSearchVolume` are not remembered, so a search that grows past your minimum is returned when it does. Searches not returned because the run hit its maximum total charge are not remembered either, so the next run returns them.

Do not run two schedules with the same `watchName` at the same time: Apify's key-value store has no atomic update, so overlapping runs can return the same search twice.

### Pricing

Pay per event:

- **Run start** - charged once per run, only when the Trending Now list of at least one country was read (with at least one search in it). This includes watch-mode runs that find nothing new and runs where `minSearchVolume` leaves nothing. Not charged when every country is `unknown-country`, `bad-input`, `no-trends`, `blocked`, `unreadable` or `timed-out`, or when the run's maximum total charge has no room for the start fee plus one result row (then nothing is requested at all).
- **Trending search** - one per `ok` row. Free rows are never charged.

The exact prices are shown on the Pricing tab.

### Measured in production (2026-10-03, build 0.1, 256 MB)

| Input | Result | Run time |
|---|---|---|
| `US`, `JP`, `GB`, `DE`, `IN`, `BR`, `US-CA`, `ZZ`, `uk` | 70 rows (10 per country), 2 free `unknown-country` rows, 9 requests | 5.9 s |
| `US`, `JP`, watch mode, first run | 20 `first-check` rows | 4.0 s |
| Same, run again a few seconds later | 0 rows, 2 free `no-new-trends` rows | 2.6 s |
| `JP`, `minSearchVolume: 10000` | 4 rows | 1.6 s |

All requests went out directly from Apify; no retry was needed.

### Support

Need another field or a country that does not work? Open an issue on the Issues tab with the input you used.

# Actor input Schema

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

Two-letter country codes as Google Trends uses them (US, GB, DE, JP, IN, BR...), or a region such as US-CA. One per line. Each country is one Trending Now list of about 10 searches, and each search is one result row. A code Google does not accept comes back as a free row that says so. Up to 150 per run. Empty = US (not allowed in watch mode).

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

Optional. Only return searches whose approximate volume (the lower bound Google shows, e.g. 2000 for "2000+") is at least this number. Searches without a volume are left out when this is set. Empty or 0 = return all.

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

On = for scheduled runs and alerts. The first run returns the whole list for each country (changeType first-check). Later runs return only searches this watch has not returned before for that country (changeType new). A country with nothing new comes back as a free no-new-trends row. A search that leaves the list and is not seen for 7 days is forgotten, so it is returned again if it trends again. Off (or empty) = always return the whole list.

## `watchName` (type: `string`):

Optional, used with watch mode. Runs with the same watch name share what has already been returned. Give a different name to each schedule. Do not run two schedules with the same watch name at the same time. Letters, digits, dot, dash and underscore.

## `resetMonitoringState` (type: `boolean`):

Forget what this watch remembered at the start of this run, so every list is a first check again. Turn it off again for scheduled runs.

## Actor input object example

```json
{
  "countries": [
    "US"
  ]
}
```

# Actor output Schema

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

One row per trending search: country, rank, search term, approximate search volume (as shown and as a number), the time Google lists for it, an image and the linked news articles. In watch mode only searches not returned before. A country code Google does not accept, an empty list, or a run that hit its maximum charge comes back as a free row that says why.

# 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"
    ]
};

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

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

```

## MCP server setup

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