# Google Trending Now (`truefetch/google-trending-now`) Actor

Google Trending Now API: choose one of 125 measured countries and a 4-hour to 7-day window, and receive one 13-field row per trending search — keyword, search volume, growth percent, Google-assigned categories, start and end times, related queries and news count. No Google credential.

- **URL**: https://apify.com/truefetch/google-trending-now.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** News, Social media, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

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 Trending Now is a google trending now api: pick a country and a time window, and get one row per trending search — keyword, search volume, growth percent, Google's own categories, start and end times, related queries and news coverage.**

- **125 countries, each one measured.** Every entry on the list was asked for trends and answered with some; the ones Google publishes nothing for are not offered.
- **13 fields per trending search**, including the volume bucket, the growth percent, and both ends of the trend's lifetime.
- **No schema ceiling on the row count.** Google applies the requested cap and returns what it currently holds; a direct August 12, 2026 check found 2,407 United States rows for seven days.
- **No Google account and no keyword to think of**; the two choices are where and how far back.

[**Run a one-result test**](https://console.apify.com/actors/truefetch~google-trending-now/input) · [**View API**](https://apify.com/truefetch/google-trending-now/api)

The smallest useful run saves one trend and bills one Actor Start plus one Result event — $0.0118 on the FREE tier.

### What does Google Trending Now do?

It answers one question — *what is this country searching for right now* — as typed rows rather than a page to read.

The Actor reads Google's Trending Now board for the country and window you choose and returns one row per trending search. Each row carries the keyword, the search-volume bucket Google assigns, the growth percent it reports, the categories it filed the trend under, when the trend started, and when it ended if it has.

What it does not do is worth stating. It does not take a keyword — Trending Now is a board of what Google surfaces, not a lookup. It does not offer categories or sort orders as inputs: Google's own request ignores a category argument, so a category filter here would be a control that changes nothing, and rows carry their categories as a field instead. And it has no affiliation with Google; it reads the same public page a browser does.

### How do I run Google Trending Now?

Three inputs, all required, all prefilled with a working combination:

1. Choose the `location` from 125 countries.
2. Choose the `time_range` — 4 hours, 24 hours, 48 hours or 7 days.
3. Set `max_results` to how many trends you want. There is no maximum.

The smallest useful run:

```json
{
  "location": "United Kingdom",
  "time_range": "Past 4 hours",
  "max_results": 2
}
```

Billing is per trend saved, so two rows bill two Result events regardless of how many the board held.

### What data does Google Trending Now return?

One row per trending search, with 13 fields in a fixed set.

| Group | Fields | Notes |
| --- | --- | --- |
| Trend | `keyword`, `search_volume`, `growth_percent` | Volume is Google's own bucket — 2000, 20000, 100000 — not an exact count. |
| Timing | `started_at`, `ended_at` | `ended_at` is null exactly while the trend is still running. |
| Classification | `categories`, `related_queries`, `news_count` | Categories are the ones Google filed the trend under, resolved to names. |
| Market | `location`, `geo` | The country as chosen, and the two-letter code Google files it under. |
| Provenance | `platform`, `processor`, `processed_at` | Which Actor produced the row, and when. |

An abbreviated and explicitly illustrative row:

```json
{
  "keyword": "rangers vs hibernian",
  "location": "United Kingdom",
  "geo": "GB",
  "started_at": "2026-08-09T06:00:00+00:00",
  "ended_at": null,
  "search_volume": 20000,
  "growth_percent": 1000,
  "categories": ["Sports"],
  "related_queries": ["rangers hibernian score"],
  "news_count": 8,
  "platform": "Google Trends",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-08-09T07:14:02+00:00"
}
```

Values Google does not publish stay null rather than being filled in.

### What inputs can I configure?

Three, and each one changes the request rather than filtering the answer afterwards.

| Input | Type | Required | Effect |
| --- | --- | --- | --- |
| `location` | select, 125 options | Yes | Which country's board to read. |
| `time_range` | select, 4 options | Yes | How far back the window reaches. Each window returns its own set. |
| `max_results` | integer | Yes | How many rows to save. Minimum 1, no maximum. |

There is deliberately no category or sort input. Google's Trending Now request accepts a category argument and ignores it — passing one returned the identical rows — so offering it would be a control that does nothing.

### What platforms and markets does Google Trending Now cover?

Google Trending Now covers one platform — Google's public Trending Now board — across 125 measured country markets and four source windows.

- **Countries** — the original list held 250 ISO entries. Each was asked for trends at the widest window; exactly half answered empty, including Antarctica and Bouvet Island, and those were removed. What remains is the set Google actually publishes for.
- **Windows** — 4 hours, 24 hours, 48 hours and 7 days, each returning its own set rather than a longer slice of the same one.
- **Volume per country** — the available count changes with the news cycle and window. A small market can legitimately return only a handful of rows.

The Actor requests English category labels for consistent downstream grouping, but the trending keyword itself remains the text Google supplies for that market. Japanese, Hindi, and other local-language queries therefore remain local-language data rather than being translated or replaced.

### Why use Google Trending Now?

Because the board arrives already typed, already categorised, and without a Google account in the way.

| Capability | What it gives a data team |
| --- | --- |
| Volume and growth as numbers | A threshold is a comparison, not a string parse. |
| Google's own categories | Classification arrives with the data instead of being inferred from the keyword. |
| Null `ended_at` for live trends | "What is trending right now" is a filter on the data. |
| No row ceiling | An oversized request returns the whole board instead of being refused. |
| No credential | No OAuth, no advertiser account, no quota to plan around. |

The trade-off is inherent to reading the public board: no keyword lookup, no historical series, and volumes as buckets rather than exact counts. Where those matter, a keyword-interest tool is the right one and this is not.

### Who is Google Trending Now for?

Google Trending Now is for developers, analysts, monitoring teams, and newsrooms that need to know what a market is searching for on a schedule.

Newsrooms tracking what a country is asking about; content teams choosing what to write while a trend is still running; researchers comparing markets on the same window; monitoring pipelines that act when growth crosses a threshold.

It is not the right fit for a team starting with a known keyword, estimating exact monthly search volume, or reconstructing long-term interest history. Use a keyword-interest product for those jobs; use this Actor when the source board itself is the discovery mechanism.

### How can I use Google Trending Now through the API or MCP?

Use the standard Apify run endpoint or the official Apify MCP integration with the same three-field JSON the Console sends. Address this Actor by its stable name form, `truefetch/google-trending-now`, in HTTP and MCP calls.

```bash
curl -X POST 'https://api.apify.com/v2/acts/truefetch~google-trending-now/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"location":"United Kingdom","time_range":"Past 4 hours","max_results":2}'
```

Ask an MCP-aware client to run `truefetch/google-trending-now` with that same input. Running Actors and reading their storage require authentication; see the [official Apify MCP documentation](https://docs.apify.com/integrations/mcp) for token and client setup.

### How much does Google Trending Now cost?

Google Trending Now costs $0.00180 per saved trend on the FREE tier plus one $0.01000 Actor Start, so the smallest one-result test totals $0.0118.

| Event | Billing unit | FREE | BRONZE | SILVER | GOLD / PLATINUM / DIAMOND |
| --- | --- | ---: | ---: | ---: | ---: |
| Result | One trending search row | $0.00180 | $0.00162 | $0.00144 | $0.00135 |
| Actor Start | One per GB of memory, minimum one | $0.01000 | $0.01000 | $0.01000 | $0.01000 |

The Actor runs at 256 MB, so every run bills exactly one Actor Start. **One trend: $0.01000 + 1 × $0.00180 = $0.0118.** These two are the only billed events; nothing else is charged per run. Prices can change; the [pricing page](https://apify.com/truefetch/google-trending-now/pricing) is authoritative.

### How does Google Trending Now compare with alternatives?

The split is between what is trending and how a keyword behaves.

- **[Google Trends Explore](https://apify.com/truefetch/google-trends-explore)** — interest over time for keywords you name, which is the opposite starting point.
- **[Google's own Trends API alpha](https://developers.google.com/search/apis/trends)** — access-gated and designed for consistently scaled interest-over-time data. This Actor reads the public Trending Now board instead, which needs no Google account and answers a different discovery question.
- **The Trending Now page in a browser** — fine for a look; it produces no rows and cannot be scheduled.

### What are the limits and troubleshooting steps?

Most surprises come from the country and the window rather than from the Actor.

- **A country not on the list is not supported**, not merely empty. The 125 offered were each measured against the source.
- **Short windows return few rows.** Four hours of a small market can be a handful; that is the board, not a failure.
- **The board moves.** The same country and window an hour apart returns a different set.
- **Filter live trends on `ended_at`**, which is null while a trend is running, rather than on `processed_at`.
- **A run returns no rows.** A valid source-empty country/window is a successful answer; widen `time_range` before treating it as an incident. If the source cannot be reached, the run fails instead of converting transport trouble into empty data.
- **A requested cap is not reached.** The source may hold fewer rows than `max_results`; the final status reports the saved count against the requested denominator.

For a reproducible issue, start with `{"location":"Canada","time_range":"Past 48 hours","max_results":2}` and open an [Issue](https://apify.com/truefetch/google-trending-now/issues) with the run ID, exact input, terminal status, and whether the Dataset was empty or only short of the requested cap.

### Frequently asked questions

#### Do I need a Google account?

No. The Actor reads the public Trending Now experience; there is no Google login, API key, quota, or advertiser account. You still need Apify authentication to start a run through the API or MCP.

#### Why 125 countries and not 250?

Because 125 is how many returned Trending Now data in the full measured coverage scan. The rest answered empty at the widest window and were removed rather than left as controls that could only return nothing.

#### Can I filter by category?

No, and that is deliberate. Google's request ignores a category argument, so the control would do nothing. Google-assigned category names instead ship in the `categories` array on each row.

#### How does google trends trending now by country work?

Choose one of 125 source-tested countries, one of four windows, and a result cap. The Actor sends those values to the public board and returns up to `max_results` rows; a direct seven-day United States request found 2,407 available rows on August 12, 2026.

#### Is there a real time google search trends api without a Google credential?

Yes for the public Trending Now discovery use case: this Actor returns the board's current and recently ended searches without a Google credential. It is not Google's access-gated Trends API alpha and does not return exact search volume or a long-term keyword series.

#### Can I schedule runs to monitor trending searches over time?

Yes. Schedule the same country and window on Apify, retain each Dataset, and compare `keyword`, `growth_percent`, `started_at`, and nullable `ended_at` between runs. The Actor does not maintain a history database inside one run.

#### What happens when fewer rows exist than max\_results?

The run succeeds with the rows the source currently holds, and the terminal status reports the saved count against your requested cap. Billing applies only to Result rows that are actually written.

### Related TrueFetch Actors

- [Google Trends Explore](https://apify.com/truefetch/google-trends-explore) — interest over time for keywords you name, rather than the board of what is trending.
- [Reddit Search API](https://apify.com/truefetch/reddit-search-api) — search Reddit discussions around a current query and capture community context.
- [Google Maps Business Listing](https://apify.com/truefetch/google-maps-business-listing) — turn a keyword and a location into structured business records.

### Support

Ask about fields, runs or billing in the [TrueFetch community on Telegram](https://t.me/TrueFetch); for a reproducible bug, open an [Issue](https://apify.com/truefetch/google-trending-now/issues) with the run ID and the exact input.

- [Store page](https://apify.com/truefetch/google-trending-now)
- [API reference](https://apify.com/truefetch/google-trending-now/api)
- [Input configuration](https://apify.com/truefetch/google-trending-now/input)
- [Pricing](https://apify.com/truefetch/google-trending-now/pricing)
- [Report an issue](https://apify.com/truefetch/google-trending-now/issues)
- [TrueFetch community](https://t.me/TrueFetch)

[**Run a one-result test**](https://console.apify.com/actors/truefetch~google-trending-now/input) · [**View API**](https://apify.com/truefetch/google-trending-now/api)

**Last Updated:** August 15, 2026

# Actor input Schema

## `max_results` (type: `integer`):

How many trending searches to save. Google applies this cap to the selected country and window; the schema leaves the upper bound open because the available source count changes over time.

## `location` (type: `string`):

Country whose Trending Now board to read. The 125 options are the countries that returned source trends in the measured coverage scan.

## `time_range` (type: `string`):

How far back the Trending Now window reaches. Wider windows can include trends that have already ended.

## Actor input object example

```json
{
  "max_results": 2,
  "location": "Canada",
  "time_range": "Past 48 hours"
}
```

# Actor output Schema

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

Open the default Dataset. Each row carries the 13 documented keys; a country Google publishes no trending searches for returns zero rows, which is a valid outcome.

# 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 = {
    "max_results": 2,
    "location": "Canada",
    "time_range": "Past 48 hours"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/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 = {
    "max_results": 2,
    "location": "Canada",
    "time_range": "Past 48 hours",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/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 '{
  "max_results": 2,
  "location": "Canada",
  "time_range": "Past 48 hours"
}' |
apify call truefetch/google-trending-now --silent --output-dataset

```

## MCP server setup

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