# Google Trends Trending Now Scraper (`fabricalabs/google-trends-trending-now`) Actor

Google Trends Trending Now searches for any country or region: search term, search volume, growth %, active or ended, start and end time, related searches, categories and optional news articles. Direct requests, no browser: fast and cheap.

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

## Pricing

from $1.00 / 1,000 trends

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What this Actor does

Get **Google Trends trending now** searches for any country or region: the searches that are surging right now on trends.google.com/trending, one row per trend, with the search volume, the growth, whether the trend is still active, when it started and ended, the related searches Google groups under it, its categories and, if you want, the news articles behind it. Pick the past 4 hours, 24 hours, 48 hours or 7 days, filter by category, and run as many countries or regions (such as `US-CA`) as you like in one go. It calls the same endpoints the website uses, with no browser, so a country takes a few seconds. **Price: $1 per 1,000 trends.**

### What data you get

| Field | What it is |
|---|---|
| `geo`, `geoName` | The code you asked for and Google's name for it, e.g. `US-CA`, `California` |
| `hours` | The time window: 4, 24, 48 or 168 hours |
| `rank` | Position in Google's list, with your filters applied, as on the website |
| `term` | The trending search |
| `searchVolume`, `searchVolumeText` | Google's search volume bucket as a number (`20000`) and as shown on the site (`20K+`) |
| `growthPercent` | How much searches grew, e.g. `1000` for +1,000% |
| `isActive` | `true` while the search is still trending |
| `startedAt`, `endedAt` | When the trend started and ended (UTC); `endedAt` is empty for active trends |
| `relatedTerms` | Other searches Google counts as part of this trend (its "trend breakdown") |
| `categories`, `categoryIds` | Category names and ids, e.g. `Sports` / `17` |
| `exploreUrl` | The term on the Google Trends explore page, for the same region and period |
| `newsArticles` | With **Include news articles** on: up to 3 articles with title, link, source, publication time and image |
| `scrapedAt` | When the row was collected (UTC) |

### How to use it

1. Enter one or more country codes (`US`, `GB`, `DE`, `BR`, `IN`...) or region codes (`US-CA`, `US-TX`, `BR-SP`) under **Countries or regions**.
2. Choose the **Time window**: past 4 hours, 24 hours, 48 hours or 7 days.
3. Optionally pick a **Category**, switch on **Active trends only**, or switch on **Include news articles**.
4. Optionally set **Maximum trends per region** to keep only the top of each list.
5. Click **Start**, then open the **Overview** table or download the results as JSON, CSV or Excel.

### Input example

```json
{
  "geo": ["US", "US-CA", "GB"],
  "hours": "24",
  "category": "17",
  "activeOnly": false,
  "includeNews": true,
  "maxItems": 50
}
```

`hours` is `"4"`, `"24"`, `"48"` or `"168"`. `category` takes the ids of the website's menu as text, for example `"17"` Sports, `"4"` Entertainment, `"3"` Business and Finance, `"18"` Technology; leave it empty for all categories.

### Output example

Trimmed from a real run (California, past 24 hours, with news):

```json
{
  "geo": "US-CA",
  "geoName": "California",
  "hours": 24,
  "rank": 10,
  "term": "australia vs brazil",
  "searchVolume": 5000,
  "searchVolumeText": "5K+",
  "growthPercent": 1000,
  "isActive": false,
  "startedAt": "2026-09-29T09:40:00Z",
  "endedAt": "2026-09-29T14:30:00Z",
  "relatedTerms": ["brazil vs australia", "brazil national football team"],
  "categories": ["Sports"],
  "categoryIds": [17],
  "exploreUrl": "https://trends.google.com/trends/explore?q=australia+vs+brazil&date=now+1-d&geo=US-CA",
  "newsArticles": [
    {
      "title": "Australia 2-4 Brazil (Sep 29, 2026) Game Analysis",
      "url": "https://www.espn.com/soccer/report/_/gameId/401881965",
      "source": "ESPN",
      "publishedAt": "2026-09-29T14:47:25Z",
      "imageUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:..."
    }
  ],
  "scrapedAt": "2026-09-29T17:20:12Z"
}
```

### How much does it cost?

**$1 per 1,000 trends** ($0.001 per trend row), plus Apify's standard start fee of $0.00005 per run. Proxy and compute are included. News articles cost nothing extra.

You are never charged for a region that fails or has no trends: those regions get a free row with an `error` or a `note` saying what happened. The run stops cleanly at your spending limit, and the status message says how many regions were left. As a guide, the United States over the past 24 hours listed about 250 trends in our tests (about $0.25); a single US state lists a few dozen.

### Use cases

- **Content and SEO**: publish on what people are searching for today, while the search is still rising.
- **Newsrooms and social media teams**: spot breaking stories per country or state, with the articles Google links to them.
- **Market and brand monitoring**: watch a category such as Business and Finance or Technology across countries every hour.
- **Datasets and AI agents**: schedule runs and feed a clean, timestamped history of trends to spreadsheets, dashboards or agents.

### Good to know

- The list changes all the time: two runs a few minutes apart can differ, just as the website does.
- `rank` follows Google's own order ("by relevance" on the website) after your filters. A busy country can list several hundred trends over 7 days; use **Maximum trends per region** to keep the top ones.
- Many trends have no `relatedTerms`: Google only groups searches when several variants trend together.
- Region codes follow ISO 3166-2 (`US-CA`, `US-TX`, `BR-SP`). A code Google does not know gets a free row explaining it, and the other regions still run.
- If the run is restarted by the platform, it resumes where it stopped without charging for the same trends twice.

### FAQ

**Does it give exact search counts?** No. Google Trends does not publish exact counts for trending searches. It sorts them into volume buckets (100+, 200+, 500+, 1K+, 2K+, 5K+ ... 1M+, 2M+), and `searchVolume` is the lower bound of that bucket, exactly what the website shows. Treat it as an order of magnitude, not a count.

**Can I get worldwide trends?** Google's Trending Now page works per country or region, so list the countries you need; each one is a separate list in the same dataset.

**How do I get news articles?** Switch on **Include news articles**. Each trend then carries up to 3 articles, the ones Google shows when you open the trend on the website.

**Do I need a Google account or a proxy?** No account. The default Apify datacenter proxy is enough.

**Can I run it on a schedule or from an AI agent?** Yes. Save your input as a task and schedule it hourly or daily, or call the Actor from AI agents through the Apify MCP server.

### Other Actors by Fabrica Labs

- [Google Trends Scraper (Fast, No Browser)](https://apify.com/fabricalabs/google-trends-fast): interest over time, interest by region and related queries for any search term.
- [Woolworths Scraper: Prices, Specials & Nutrition](https://apify.com/fabricalabs/woolworths-au-products): product prices, specials and nutrition from woolworths.com.au.
- [Google Play Apps Scraper](https://apify.com/fabricalabs/google-play-apps): search rankings, app details and reviews from Google Play.

This Actor collects the public, aggregated and anonymous statistics shown on trends.google.com. It is not affiliated with or endorsed by Google.

# Changelog

This Actor's version history is a separate document: https://apify.com/fabricalabs/google-trends-trending-now/changelog.md

# Actor input Schema

## `geo` (type: `array`):

One code per line: a two-letter country code (US, GB, DE, BR, IN...) or a region code in ISO 3166-2 form (US-CA, US-TX, BR-SP). Each code gets its own list of trends, exactly like choosing a location on trends.google.com/trending.

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

How far back to look for searches that started trending: the past 4 hours, 24 hours, 48 hours or 7 days, as on the website.

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

Only keep trends Google files under this category. Leave on 'All categories' to get every trend. A trend can belong to several categories.

## `activeOnly` (type: `boolean`):

When on, only searches that are still trending are returned; trends that have ended are left out.

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

Adds up to 3 news articles per trend (title, link, source, publication time, image), the ones Google shows in the trend's panel. Takes about one extra request per 50 trends; the price per trend stays the same.

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

Stop after this many trends for each country or region, in the order Google lists them. 0 means no limit (a busy country can have several hundred trends over 7 days).

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

Language code sent to Google Trends, e.g. en-US, es, pt-BR. It changes the region names; the search terms are always what people typed.

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

Google Trends limits how often one IP can ask. The default Apify datacenter proxy is enough for this Actor; if your account has no proxy, it connects directly.

## Actor input object example

```json
{
  "geo": [
    "US"
  ],
  "hours": "24",
  "category": "",
  "activeOnly": false,
  "includeNews": false,
  "maxItems": 0,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per trending search: rank, search volume, growth, status, categories and related searches.

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

Every field, including start and end times, category ids and news articles when requested.

# 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 = {
    "geo": [
        "US"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabricalabs/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 = {
    "geo": ["US"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabricalabs/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 '{
  "geo": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabricalabs/google-trends-trending-now --silent --output-dataset

```

## MCP server setup

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