# Trending Searches Today 🔥 (Google Trends by country) (`tagadanar/trending-searches-today`) Actor

What is trending on Google right now, by country. Every trending search with its search-volume estimate, how fast it is climbing, when it started, whether it is still rising, its category and the queries breaking out around it. Several countries in one run. No API key, usage included.

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

## Pricing

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

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

## Trending Searches Today (Google Trends, by country)

What people are searching for on Google right now, country by country. Every
trending search with the number of searches behind it, how fast it is climbing,
when it started, whether it is **still rising** at this moment, which category
Google filed it under, and the cluster of queries breaking out around it.

One job: you open your laptop and want to know what is trending today, in the
countries you publish in, in one file.

### Why not just open the Trending Now page

Because the page shows you one country at a time, now, on screen. Its CSV button
exports whatever country and filter you currently have open, by hand, and by the
time you have done that for six countries the top of the list has moved.

This actor takes the countries as a list, runs on a schedule, and puts one row
per trend per country into a dataset you can diff against yesterday's. It also
keeps the fields the page only hints at: the exact epoch the trend started, the
epoch it stopped trending (empty while it is still climbing), how many hours it
has been running, and the full breakdown of queries feeding it — the page shows
you the first three and a "+10 more".

The paid tools that sell this layer are subscriptions built around a dashboard
rather than a feed you can join to your own data — Glimpse, the best known of
them, starts at around $50 a month (checked 2026-08-17). This actor charges
**$0.001 per trend** and nothing else but a $0.001 start.

### The same job, priced across the store

100 trending searches for one country, one run, at list price:

| actor | the same job | notes |
| --- | ---: | --- |
| `primevision/google-trends-radar` | $0.040 | $0.02 start plus $0.0002 a row — cheaper than us past ~30 rows, dearer below it |
| **this actor** | **$0.101** | $0.001 start plus $0.001 a row |
| `data_xplorer/google-trends-trending-now` | $0.120 | $0.02 start plus $0.001 a row. 41 users in 30 days, the incumbent here |
| `truefetch/google-trending-now` | $0.190 | $0.01 start plus $0.0018 a row |
| `dr_ben/google-trending-searches` | $0.200 | $0.002 a row |
| `easyapi/google-realtime-trends-data-scraper` | $0.389 | $0.09 start plus $0.00299 a row |

Prices read from the public Store API on 2026-08-19. We are not the cheapest at
volume and there is no point pretending otherwise: `primevision` wins past about
30 rows a run. What you get here instead is the still-rising flag, the start and
end times, the corrected category labels and several countries in one dataset.

### What you get, per trend

| field | what it is |
| --- | --- |
| `rank` | position within its country, biggest search volume first |
| `query` | the trending search, exactly as Google writes it |
| `normalizedQuery` | the same query with diacritics folded to plain ASCII, for joining |
| `geo`, `geoName` | the country the trend belongs to |
| `searchVolume`, `searchVolumeText` | Google's estimate as a lower bound: `200000` and `200K+` |
| `volumeGrowthPct` | percent growth, capped by Google at 1000 |
| `isBreakout` | true at that 1000% ceiling, which is Google's own "this exploded" marker |
| `startedAt` | when the trend started climbing |
| `endedAt` | when it stopped. Empty means it has not stopped |
| `isActive` | true while it is still rising |
| `trendingForHours` | how long it has been running, in hours |
| `categories`, `categoryIds` | Google's own categories, as words and as ids |
| `relatedQueries` | the whole cluster of queries feeding the trend, not just the first three |
| `trendsUrl`, `newsSearchUrl` | the trend on Google Trends, and a news search for it |

#### About search volume

Google publishes trending volume as a **lower bound**, in buckets: 100, 200,
500, 1000, 2000, 5000, 20000, 200000 and so on. `200K+` means at least two
hundred thousand searches, not exactly. Nobody selling this data has the exact
number, because Google does not publish it. `searchVolume` keeps the bucket as a
number so you can sort and threshold on it.

#### About news articles

Google's Trending Now used to ship the news articles behind each trend. It does
not any more: the feed carries no article tokens, the RSS version's news
elements are empty, and the Trending Now page itself renders no article links at
all (all three checked 2026-08-19). So this actor does not claim to return news
articles — it gives you `newsSearchUrl`, an honest link out, and any actor still
advertising per-trend articles from this source is worth a second look.

### Input

Today's trends in the United States:

```json
{
  "countries": ["US"],
  "hours": "24",
  "maxTrendsPerGeo": 25
}
```

Six markets at once, only what is still climbing right now:

```json
{
  "countries": ["US", "GB", "FR", "DE", "BR", "IN"],
  "hours": "24",
  "stillRisingOnly": true,
  "maxTrendsPerGeo": 50
}
```

The week's biggest sports trends in one country:

```json
{
  "countries": ["GB"],
  "hours": "168",
  "category": "17",
  "maxTrendsPerGeo": 200
}
```

| input | |
| --- | --- |
| `countries` | two-letter country codes, one or more. One row per trend per country |
| `hours` | how recently a trend must have started: 4, 24, 48 hours or 7 days |
| `category` | one of Google's 19 categories, or all of them |
| `stillRisingOnly` | keep only the trends Google has not marked as finished |
| `maxTrendsPerGeo` | the row cap per country, applied after sorting by volume — also your cost ceiling |

### Use cases

**Newsroom and content desks.** Run it hourly with `hours: "4"` and
`stillRisingOnly`, and you have the list of things gaining attention right now,
ranked, with the query cluster to write against.

**Publishing in several markets.** One run, six countries, one dataset. The same
story trends at different hours in different countries and the `startedAt` column
is how you see that.

**Affiliate and e-commerce.** Filter to Shopping or Games and watch what shows
up before your competitors' merch does.

**Feeding a dashboard.** Schedule it daily, append to the same dataset, and
`isActive` plus `trendingForHours` gives you trend lifetimes over time — which
is data nobody publishes, because it only exists if you sampled it.

### Questions people ask

**Is this real Google Trends data?** Yes, from the same endpoint the
trends.google.com/trending page calls for itself. Nothing is modelled or
estimated by us.

**Are the search volumes exact?** No, and they cannot be. Google publishes them
as lower bounds in buckets and this actor passes them through unchanged.

**Which countries work?** Any country with a Google Trends trending feed. `US`
and `FR` were measured directly (478 and 303 trends in a 24 hour window on
2026-08-19); the rest of the country list is the one the Trending Now page's own
country picker offers. A code with no feed comes back empty and is named in the
run's status message rather than silently dropped.

**Why did my run come back with no rows?** Either your filters were too narrow —
the log tells you exactly how many trends survived each one — or the country you
asked for has no feed. If Google itself stops answering, the run **fails**. It
never finishes green with an empty dataset.

**Do I need an API key or a proxy?** Neither. Platform usage is included in the
price.

**Can I schedule it?** That is the point. Point a daily or hourly schedule at it
and diff the datasets.

### Related actor

For keyword-level Google Trends work — bulk keyword lists, interest over time,
interest by region — see **Google Trends Scraper (Bulk Keyword Lists & Trending
Now)** on the same profile, and for putting two to five keywords on one shared
scale with their seasonality, see **Keyword Comparison & Seasonality**. This
actor is the narrow one: what is trending right now, by country, meant to be
re-run.

***

Keywords: google trending searches today, trending now search volume, trending
keywords by country, what is trending on google right now, daily trending
searches api, google trends trending now scraper, breakout search terms, real
time search trends by country, trending topics scraper, hourly trending searches.

# Actor input Schema

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

Two-letter country codes, one per line — for example <code>US</code>, <code>GB</code>, <code>FR</code>, <code>DE</code>, <code>IN</code>, <code>BR</code>, <code>JP</code>. Google keeps a separate trending feed per country and you get one row per trend per country, so several countries in one run is one dataset you can pivot.

## `hours` (type: `string`):

How far back a trend is allowed to have started. 24 hours is "what is trending today". 4 hours is the breaking-news view. 7 days catches the whole week and returns thousands of trends, so pair it with the row cap below.

## `category` (type: `string`):

Keep only trends Google filed under one category. Leave it on "All categories" for the full feed. Trends can carry more than one category, and a trend is kept when any of them matches.

## `stillRisingOnly` (type: `boolean`):

Google marks a trend finished by stamping it with an end time. Tick this to keep only the ones with no end time yet — the trends still climbing at the moment of the run, which is what you want if you are deciding what to publish in the next hour.

## `maxTrendsPerGeo` (type: `integer`):

The cap on rows per country, applied after the filters and after sorting by search volume, so you always get the biggest ones. This is also your cost ceiling: you pay per row.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "hours": "24",
  "category": "",
  "stillRisingOnly": false,
  "maxTrendsPerGeo": 25
}
```

# Actor output Schema

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

One record per trending search per country, biggest first.

# 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"
    ],
    "maxTrendsPerGeo": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/trending-searches-today").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"],
    "maxTrendsPerGeo": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/trending-searches-today").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"
  ],
  "maxTrendsPerGeo": 25
}' |
apify call tagadanar/trending-searches-today --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tagadanar/trending-searches-today"
        }
    }
}

```

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/YUklc9F7TDzbqjj1L/builds/4lmoEBbaJj5xUnYjG/openapi.json
