# Google Trending Now — Free Daily Trending Searches by Country (`datarock/google-trending-now`) Actor

Free: get Google Trending Now searches for 125 countries, with rank, approximate search volume, start time, image and related news headlines. Export to JSON, CSV or Google Sheets. Not affiliated with Google.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 Trending Now — Free Daily Trending Searches

Get what people are searching on Google right now in 125 countries (plus US states, other regions and US metro areas): rank, approximate search volume as text and as a number, when the trend started, an image and related news headlines. Run it once, or schedule it and get a daily digest in Slack, Google Sheets or your own app.

> **Free.** This Actor has no usage fee. Like any Actor, each run uses a small amount of Apify platform compute, paid from your Apify credits. In our tests, 3 countries took about 6 s and cost about $0.0003 in platform usage; 22 countries took about 85 s and cost about $0.001.
>
> Not affiliated with, endorsed by, or sponsored by Google. "Google Trends" is a trademark of Google LLC.

### Features

- **Many countries in one run.** Pass a list of codes; each country is fetched separately.
- **Up to 10 trends per country**, the top of Google's Trending Now feed for that country. In our test, 119 of 125 countries returned the full 10; a few small markets return fewer (e.g. Albania 7, Bahrain 5, Cuba 1).
- **Regions and metros.** Sub-national codes such as `US-CA`, `US-NY`, `DE-BY`, `GB-SCT`, `IN-MH` and US metro (DMA) codes such as `501` (New York) also work.
- **Numeric search volume.** `trend_volume` as Google shows it (`"2000+"`) and `trend_volume_raw` as a number, so you can sort and filter.
- **Sort** by Google order, search volume, most recent, or title.
- **Related news headlines** (title, URL, source), 1–10 per trend. Can be turned off.
- **Flat output** for CSV / Excel / Google Sheets: one row per trend, news joined into text columns.
- **Only new since last run** for scheduled digests: skip trends you already got.
- **Per-country status.** An unsupported code returns one item with `status: "unsupported_country"`; a country that fails returns `status: "error"` or `"rateLimited"`. The other countries are always processed and the run itself does not fail.
- **Run report** saved to the key-value store as `RUN_REPORT`: countries requested, succeeded, unsupported, failed, items, run time.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `countries` | array of strings | `["US"]` | Country codes (`US`, `GB`, `DE`…), regions (`US-CA`) or US metro codes (`501`). `UK` is accepted as `GB`. |
| `maxItemsPerCountry` | integer | `0` | `0` = all trends in the feed (up to 10). |
| `sortBy` | string | `relevance` | `relevance` (Google order), `volume`, `recency` or `title`. |
| `includeNews` | boolean | `true` | Add related news articles to each trend. |
| `newsPerTrend` | integer | `3` | News articles per trend (1–10). |
| `outputFormat` | string | `nested` | `nested` (JSON arrays) or `flat` (one text row per trend). |
| `onlyNewSinceLastRun` | boolean | `false` | Skip trends already returned by a previous run with the same countries. |
| `stateKey` | string | auto | Optional name for the "only new" state. |
| `proxyConfiguration` | object | no proxy | Optional. Not needed for normal use. |

#### One-click example

The defaults work as they are: clicking **Start** returns the current trends for the US with news. A multi-country run for a spreadsheet:

```json
{ "countries": ["US", "GB", "DE", "IN", "BR"], "sortBy": "volume", "outputFormat": "flat" }
```

### Output fields

| Field | Description |
|---|---|
| `dataType` | Always `trendingNow` |
| `status` | `ok`, or `unsupported_country` / `error` / `rateLimited` for a country with no data |
| `source` | `rss`: Google's Trending Now feed |
| `geo` / `country` / `region` | Requested code / its country / the region or metro code (null for a country) |
| `rank` / `googleRank` | Position in your sort order / position in Google's list |
| `title` / `term` / `query` | The trending search (same value) |
| `trend_volume` / `approxTraffic` | Approximate searches as shown by Google, e.g. `"2000+"` |
| `trend_volume_raw` | The same as a number, e.g. `2000` |
| `started_at` | When Google published the trend (ISO 8601) |
| `picture` | Image URL for the trend |
| `news` / `news_count` | Related headlines `[{ "title", "url", "source" }]` and their number |
| `news_titles` / `news_urls` / `news_sources` | Flat output only: headlines joined with `\|` |
| `trends_url` | Google Trends explore page for the term in that geo |
| `scraped_at` | When the run collected the data (ISO 8601) |
| `errorMessage` | Only on non-ok items |

Fields `category`, `categories`, `related_terms`, `ended_at`, `is_active`, `language`, `timeframe_hours` and `percentIncrease` are reserved and are empty in this free version, because the feed does not include them.

#### Output example (values illustrative)

```json
{
  "dataType": "trendingNow", "status": "ok", "source": "rss", "geo": "US", "country": "US", "region": null,
  "rank": 1, "googleRank": 1, "title": "example trending search", "term": "example trending search",
  "trend_volume": "200000+", "trend_volume_raw": 200000, "started_at": "2026-10-23T14:00:00.000Z",
  "picture": "<image url>", "news": [{ "title": "Example headline", "url": "<article url>", "source": "Example News" }], "news_count": 1,
  "trends_url": "<Google Trends explore URL>", "scraped_at": "2026-10-23T16:00:00.000Z"
}
```

An unsupported code:

```json
{ "dataType": "trendingNow", "status": "unsupported_country", "geo": "XX", "country": "XX", "errorMessage": "Google Trends has no Trending Now feed for \"XX\"", "scraped_at": "2026-10-23T16:00:00.000Z" }
```

### Recipes

#### Run from n8n or Make with one HTTP request

Use an **HTTP Request** node (n8n) or **HTTP → Make a request** module (Make):

- Method: `POST`
- URL: `https://api.apify.com/v2/acts/datarock~google-trending-now/run-sync-get-dataset-items?format=json`
- Header: `Authorization: Bearer <your Apify API token>`
- Body (JSON): `{ "countries": ["US", "GB"], "outputFormat": "flat" }`

The response is the list of trends. Add a filter `status = ok`, then send to **Slack** or **Google Sheets → Append row**. Use `format=csv` in the URL to get CSV instead.

#### Daily digest

1. In Apify Console, open this Actor → **Schedule** → every day at 08:00 with your input and `onlyNewSinceLastRun: true`.
2. In n8n or Make use the **Apify** app (trigger "Actor run finished", then "Get dataset items").
3. Filter `status = ok` and map `geo`, `rank`, `term`, `trend_volume_raw`, `news_titles` to your sheet or channel.

The same output works from your own code through the Apify API and client libraries, and from AI agents through the Apify MCP server.

### FAQ

**Is it free?**
Yes. There is no per-result or rental fee. Platform compute is paid from your Apify credits; a run of a few countries costs a fraction of a cent.

**Which countries are supported?**
125 countries were verified before release (codes): AE, AL, AM, AO, AR, AT, AU, AZ, BA, BD, BE, BF, BG, BH, BJ, BO, BR, BY, CA, CD, CH, CI, CL, CM, CO, CR, CU, CY, CZ, DE, DK, DO, DZ, EC, EE, EG, ES, ET, FI, FR, GB, GE, GH, GR, GT, HK, HN, HR, HT, HU, ID, IE, IL, IN, IQ, IR, IT, JM, JO, JP, KE, KG, KH, KR, KW, KZ, LB, LK, LT, LV, LY, MA, MD, MK, ML, MM, MX, MY, MZ, NG, NI, NL, NO, NP, NZ, OM, PA, PE, PH, PK, PL, PR, PS, PT, PY, QA, RO, RS, RU, SA, SE, SG, SI, SK, SN, SV, SY, TH, TM, TN, TR, TT, TW, TZ, UA, UG, US, UY, UZ, VE, VN, YE, ZA, ZM, ZW.
Regions (e.g. `US-CA`, `DE-BY`) and US metro codes (e.g. `501`) also work. Any other code returns `status: "unsupported_country"` and the run continues.

**How many trends do I get per country?**
Up to 10, the top of Google's Trending Now feed. Smaller markets can have fewer at a given moment.

**Can I choose the time window, category, or get related queries?**
Not in this free version; it returns the current top trends per country.

**What if Google blocks a request?**
The Actor retries with backoff. If a country still fails, you get an item with `status: "rateLimited"` or `"error"`, and the other countries are still processed. You can also turn on Apify Proxy in the input.

**How often does the list change?**
Google updates Trending Now through the day. Schedule runs as often as you need.

**Personal data?**
No. Trending searches are aggregated, and the Actor does not log in anywhere.

# Actor input Schema

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

ISO 2-letter country codes (125 verified, e.g. US, GB, DE, IN, BR, JP), sub-national regions like US-CA or DE-BY, or US metro codes like 501. Many per run. A code Google does not support returns one item with status 'unsupported_country'; other countries still run.

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

Order within each country. 'rank' follows this order; 'googleRank' keeps Google's original position.

## `maxItemsPerCountry` (type: `integer`):

0 = all trends in Google's Trending Now feed for the country (up to 10). Set lower to keep only the top N.

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

Add related news headlines (title, URL, source, published time, image) to each trend.

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

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

## `outputFormat` (type: `string`):

'flat' joins related terms and news into text columns, so CSV/Excel/Sheets exports have one clean row per trend.

## `onlyNewSinceLastRun` (type: `boolean`):

For scheduled runs: skip trends already returned by a previous run with the same countries (state kept in a named key-value store in your account).

## `stateKey` (type: `string`):

Custom name for the 'only new' state, if you run several schedules with the same settings.

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

Optional; not needed for normal use. Enable only if you see status 'rateLimited'.

## Actor input object example

```json
{
  "countries": [
    "US",
    "GB",
    "DE",
    "IN",
    "BR"
  ],
  "sortBy": "relevance",
  "maxItemsPerCountry": 0,
  "includeNews": true,
  "newsPerTrend": 3,
  "outputFormat": "nested",
  "onlyNewSinceLastRun": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `trends` (type: `string`):

All trends with rank, traffic, start time and news, as JSON/CSV/Excel.

## `trendsTable` (type: `string`):

No description

# 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",
        "GB",
        "DE",
        "IN",
        "BR"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datarock/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 = { "countries": [
        "US",
        "GB",
        "DE",
        "IN",
        "BR",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datarock/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 '{
  "countries": [
    "US",
    "GB",
    "DE",
    "IN",
    "BR"
  ]
}' |
apify call datarock/google-trending-now --silent --output-dataset

```

## MCP server setup

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