# Google Trends Trending Now Scraper — Searches by Country (`genial_candlestand/google-trending-now-scraper`) Actor

Get Google Trends Trending Now searches: title, search volume, growth %, start and end time, categories, related queries and news articles. Many countries and subregions per run, 1–168 h window, no login. $0.85 per 1,000 trends.

- **URL**: https://apify.com/genial_candlestand/google-trending-now-scraper.md
- **Developed by:** [Flowo](https://apify.com/genial_candlestand) (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

Pay per event

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 Scraper — Daily & Real-Time Searches

This actor returns the trending searches of Google Trends "Trending Now" for any country or subregion: the trend title, search volume, growth percentage, start and end time, categories, related queries and linked news articles. One flat row per trend, no login, many countries in a single run.

### What does this actor do?

Give it a list of country codes (`US`, `DE`, `JP`) or subregions (`US-CA`, `GB-SCT`) and a time window from 1 to 168 hours. It reads the same Trending Now list that is shown on trends.google.com/trending and returns one row per trending search, with `searchVolume`, `increasePercentage`, `startedAt`, `endedAt`, `isActive`, `categories`, `relatedQueries` and `newsArticles`.

It is built for content and SEO teams, newsrooms, marketers, traders and alert bots, and for AI agents that answer "what is trending in Germany right now?".

### How to use

1. Open the actor in Apify Console and click **Try for free**.
2. Enter one or more country codes under **Countries or subregions** (default `US`).
3. Choose the time window in hours (default 24), and optionally categories, status, minimum search volume and sort order.
4. Click **Start** and download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

AI agents can call the actor through the Apify API or Apify MCP server with the same input JSON.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Trending search (one row) | $0.00085 — **$0.85 per 1,000 trends** |
| Actor start | $0.00005 (Apify's standard start price, per GB of memory) |

Example: the top 100 US trends of the past 24 hours cost about $0.085 plus the start fee. Unsupported geos, empty lists and trends skipped by "Only new trends" are free. Apify subscription tiers may give discounts.

### Input

| Field | What it does |
|---|---|
| `geos` | Country (ISO 3166-1) or subregion (ISO 3166-2) codes, one per line. Default `["US"]`. |
| `hours` | Trends started in the past N hours, 1–168 (website windows: 4, 24, 48, 168). Default 24. |
| `maxItemsPerGeo` | Max trends per geo after filters and sorting, 1–5000. Default 100. |
| `sortBy` | `relevance`, `searchVolume`, `recency` or `title`. |
| `categories` | Keep trends in any of 19 categories (sports, politics, technology…). Empty = all. |
| `status` | `all`, `active` or `ended`. |
| `minSearchVolume` | Keep trends with at least this search volume. |
| `includeNews`, `newsPerTrend` | Add 1–30 news articles per trend (default 3). |
| `onlyNew`, `onlyNewKey` | Return only trends not returned by earlier runs with the same memory name. |
| `maxItems` | Total cap across all geos. |
| `language` | Interface language (`hl`), default `en-US`. |

Example input:

```json
{
  "geos": ["US", "GB", "DE"],
  "hours": 24,
  "sortBy": "searchVolume",
  "maxItemsPerGeo": 25,
  "newsPerTrend": 3
}
```

### Output

| Field | Meaning |
|---|---|
| `position` | Rank in the sorted list of the geo |
| `title` | The trending search |
| `geo`, `country` | Requested geo code and its country |
| `searchVolume`, `searchVolumeFormatted` | Google's lower-bound volume (e.g. 500000, "500K+") |
| `increasePercentage` | Growth in searches (Google caps it at 1000) |
| `startedAt`, `endedAt`, `isActive` | Start and end time (null while still active) |
| `categories`, `category` | Google categories of the trend |
| `relatedQueries` | Queries related to the trend |
| `newsArticles`, `newsArticleCount` | Articles with title, url, source, publishedAt, imageUrl |
| `topNewsTitle`, `topNewsUrl`, `topNewsSource`, `imageUrl` | First article as flat columns for spreadsheets |
| `url`, `scrapedAt` | Google Trends explore link and scrape time |

Example item (shortened):

```json
{
  "position": 1,
  "title": "knicks vs celtics",
  "geo": "US",
  "country": "US",
  "timeWindowHours": 24,
  "searchVolume": 500000,
  "searchVolumeFormatted": "500K+",
  "increasePercentage": 1000,
  "startedAt": "2026-10-23T20:50:00.000Z",
  "endedAt": null,
  "isActive": true,
  "categories": ["Sports"],
  "relatedQueries": ["knicks vs celtics", "bulls vs bucks", "hawks vs hornets"],
  "newsArticleCount": 52,
  "newsArticles": [
    {
      "title": "Houston Rockets vs San Antonio Spurs Oct 23, 2026 Box Scores",
      "url": "https://www.nba.com/game/hou-vs-sas-0022600009/box-score",
      "source": "NBA.com",
      "publishedAt": "2026-10-23T20:25:58.000Z"
    }
  ],
  "topNewsSource": "NBA.com",
  "url": "https://trends.google.com/trends/explore?q=knicks+vs+celtics&date=now+7-d&geo=US&hl=en-US",
  "scrapedAt": "2026-10-24T09:50:10.246Z"
}
```

### Use cases

- **Daily topic research** for newsrooms and content teams: the top trends of a market with news links.
- **Multi-market monitoring**: compare the biggest trends of several countries in one dataset.
- **Niche tracking**: active sports, technology or politics trends of a state or region.
- **Scheduled alerts**: run hourly with "Only new trends" and a minimum search volume to get only fresh trends.
- **Research exports**: the full 7-day list of a country as CSV, without news, for analysis.

### Limitations

- Trending Now has no worldwide list; only supported countries (about 125) and their subregions. Unsupported codes such as `CN` are skipped with a warning.
- The window always ends now; there are no historical dates.
- Search volumes are coarse lower bounds, not exact numbers, and `increasePercentage` is capped at 1000.
- The same title can appear twice in one geo and window with different start times.
- Large 7-day lists (the US has about 3,400 trends) take longer, especially with news.
- The data comes from an undocumented Google endpoint that can change without notice.
- Trend titles are not translated by `language`; news follows the trend's geo.

### FAQ

**Is it legal to scrape Google Trends?**
The actor reads public data shown on trends.google.com without login and returns no personal data beyond what the page shows. You are responsible for using the data in line with Google's terms and the laws that apply to you.

**How is this different from a Google Trends interest scraper?**
This actor lists what is trending now, per country and time window. For interest over time of your own keywords, see the actor below.

**Can I get only new trends on each run?**
Yes. Turn on `onlyNew` and give each schedule its own `onlyNewKey`. Skipped trends are not charged.

**Can I turn off news?**
Yes, set `includeNews` to false for faster runs.

### Other actors

Related Google data actors from the same author:

- [Google Trends Scraper — Interest, Regions & Related Queries](https://apify.com/genial_candlestand/google-trends-scraper) — interest over time and by region for your own search terms.
- [Google Ads Transparency Scraper — Domain & Advertiser Ads](https://apify.com/genial_candlestand/google-ads-transparency-scraper) — ads of any domain or advertiser.
- [Google Play Reviews Scraper — Ratings, Replies & Versions](https://apify.com/genial_candlestand/google-play-reviews-scraper) — app reviews from Google Play.

# Actor input Schema

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

One code per line: a country code (US, DE, JP) or a subregion (US-CA, GB-SCT). About 125 countries are supported; Worldwide is not available on Trending Now. Lower case is accepted and UK is read as GB. Unsupported codes are skipped with a warning.

## `hours` (type: `integer`):

Trends started in the past N hours: 4, 24, 48 or 168 (7 days) as on the website, or any whole number from 1 to 168. The window always ends now.

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

At most this many trends per country or subregion, after filters and sorting (e.g. the top 25 by search volume).

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

Order of the trends of each geo before the per-geo limit is applied. Relevance is Google's default order on the website.

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

Keep only trends in any of these categories (a trend can have several). Empty = all categories. Works for every geo and time window.

## `status` (type: `string`):

All trends, only trends that are still active (searches still rising), or only trends that have ended.

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

Keep only trends with at least this search volume (Google's lower bound, e.g. 10000 keeps 10K+ and more). 0 = no minimum.

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

Add the news articles Google links to each trend (title, URL, source, time, image). Turn off for faster runs; News articles per trend is then ignored.

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

How many news articles to fetch per trend, 1–30 (Google returns fewer when a trend has fewer). Only used with Include news articles.

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

For scheduled alerts: return only trends not returned by earlier runs with the same Only-new memory name (same geo, title and start time). The first run returns everything. Skipped trends are free.

## `onlyNewKey` (type: `string`):

Name of the memory of already returned trends, used only with Only new trends. Give each schedule its own name (letters, digits, - and \_), e.g. us-sports-alerts.

## `maxItems` (type: `integer`):

Stop after this many rows across all geos. Empty = no total limit (only Max trends per geo applies).

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

Interface language code sent to Google (hl), e.g. en-US, de, ja. It does not translate trend titles (they are what people searched) and news follows the geo; category names are always English.

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

Proxy settings. Apify datacenter proxy (default) works; no blocking was observed.

## Actor input object example

```json
{
  "geos": [
    "US"
  ],
  "hours": 24,
  "maxItemsPerGeo": 100,
  "sortBy": "relevance",
  "categories": [],
  "status": "all",
  "minSearchVolume": 0,
  "includeNews": true,
  "newsPerTrend": 3,
  "onlyNew": false,
  "onlyNewKey": "default",
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with all trending searches

## `overview` (type: `string`):

Trending searches, overview view

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

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

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

```

## MCP server setup

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

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/DjnFDx6OoLnLG4VqK/builds/YW7kYrR6ziFPWLdmz/openapi.json