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

Collect Google Trends Trending Now searches for up to 50 countries and regions in one run: search volume, increase, start and end time, categories and related searches. No login.

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

## Pricing

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

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

Get the **Trending Now** list from Google Trends for **many countries and regions in a single run**: what people are searching for right now, how many searches, how fast it is growing, when the trend started or ended, its categories and the related searches. No browser and no login needed.

### What you get

For every trending search in every country or region you ask for, one row with:

- the search itself and its **position** in Google's list
- **search volume** (e.g. `200K+`) and the **increase** in percent
- **start time**, **end time** and whether the trend is **still active**
- **categories** (a trend can have several, e.g. Sports and Entertainment)
- **related searches** that Google groups under the trend
- a ready-made **Google Trends Explore link** for the search in the same country or region

A run summary tells you, for each country or region, whether it worked and how many rows it returned.

### Why use it

- **Up to 50 countries or regions per run.** Compare what the US, Japan, Germany and Brazil are searching for with one click, or watch a single US state.
- **All four time windows** Google offers: past 4 hours, 24 hours, 48 hours and 7 days.
- **Filters built in**: keep only some categories, only active or only ended trends, or the top N per country.
- **Pay only for results.** You pay for each trending search saved, not for failed countries.

Typical uses: content and SEO teams picking today's topics, marketers comparing interests across markets, and data or AI pipelines that collect trends on a schedule.

### Input

| Field | What it does | Default |
|---|---|---|
| `countries` | Country codes ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2), e.g. `US`, `KR`, `JP`) or region codes (e.g. `US-CA`, `JP-13`). 1 to 50 per run. Duplicates are merged. | `["US"]` |
| `hours` | Time window in hours: `4`, `24`, `48` or `168` (7 days). | `24` |
| `categories` | Keep trends that have at least one of these categories. Empty means all. | all |
| `status` | `all`, `active` (still trending) or `ended`. | `all` |
| `maxItemsPerCountry` | Keep at most this many trends per country or region, in Google's order, after the other filters. Empty means all. | all |

Example input:

```json
{
  "countries": ["US", "GB", "JP", "US-CA"],
  "hours": 24,
  "categories": ["Sports", "Entertainment"],
  "status": "active",
  "maxItemsPerCountry": 20
}
```

Wrong country code formats, an unsupported `hours` value, or more than 50 countries are rejected before any request is made, with a message that says which field is wrong.

### Output

One row per trending search. A real row (related searches shortened):

```json
{
  "location": "US-CA",
  "countryCode": "US",
  "rank": 1,
  "query": "wnba finals",
  "searchVolume": 200000,
  "searchVolumeLabel": "200K+",
  "increasePercent": 1000,
  "startedAt": "2026-10-17T04:30:00Z",
  "endedAt": null,
  "isActive": true,
  "categories": [{ "id": 17, "name": "Sports" }],
  "relatedQueries": ["finales de la wnba", "dream vs valkyries", "valkyries", "valkyries game"],
  "hours": 24,
  "exploreUrl": "https://trends.google.com/trends/explore?q=wnba+finals&geo=US-CA&hl=en-US",
  "scrapedAt": "2026-10-18T01:47:01Z"
}
```

| Field | Meaning |
|---|---|
| `location` | The country or region you asked for |
| `countryCode` | Its country (for `US-CA` this is `US`) |
| `rank` | Position in Google's list ("By relevance"), before your filters. Starts at 1 |
| `query` | The trending search |
| `searchVolume` / `searchVolumeLabel` | Lower bound of searches, as a number and as Google shows it (`200K+`) |
| `increasePercent` | Increase in searches, in percent |
| `startedAt` / `endedAt` | When the trend started and ended (ISO 8601, UTC). `endedAt` is `null` while it is active |
| `isActive` | `true` while the trend is still active |
| `categories` | Category IDs and names |
| `relatedQueries` | Related searches grouped under the trend |
| `hours` | The time window you asked for |
| `exploreUrl` | Google Trends Explore link for this search in the same country or region |
| `scrapedAt` | When the row was collected (UTC) |

You can download the results as JSON, CSV, Excel, XML or HTML, or read them through the Apify API.

#### Run summary

The key-value store record `OUTPUT` sums up the run:

```json
{
  "status": "SUCCEEDED",
  "stopReason": null,
  "totalItems": 310,
  "locations": [{ "location": "US-CA", "status": "ok", "items": 310, "itemsBeforeFilter": 310 }]
}
```

- `SUCCEEDED`: every country or region worked.
- `PARTIAL`: some failed, or your maximum charge for the run was reached. Then the remaining countries, and any country being collected that could not save a single row, are marked `not_attempted` (not charged, and you can run them again), and a `note` explains why. The run still counts as successful.
- `STOPPED`: Google asked for a CAPTCHA or a login, refused access, or rate-limited two different countries. The run stops right away, keeps the rows it already saved and marks the rest `not_attempted`. It does not try to get around these checks.

If Google rate-limits one country, that country is marked `failed` and is not retried; the others continue. Only proxy connection problems (such as a timeout) are retried with a new IP.

### Pricing

Pay per event:

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Each trending search saved | $0.0004 | $0.0003 | $0.00025 | $0.0002 |
| Run start | $0.005 | $0.005 | $0.005 | $0.005 |

Example: 10 countries at about 300 trends each is about 3,000 rows. On the Bronze plan that is $0.005 + 3,000 × $0.0003 = **about $0.91**. Countries that fail are not charged. Use the run's maximum charge setting to cap a run; the actor then saves only what fits and stops cleanly.

### Good to know

- **Search volume is a range, not an exact count.** `200K+` means at least 200,000 searches. This is how Google Trends reports it.
- **The list changes all the time.** Trending Now is a live list, so two runs a few minutes apart can return different trends or a different order. Results reflect the moment of the run, and past dates are not available.
- **It relies on the same internal web calls the Google Trends site uses.** If Google changes them, runs can fail until the actor is updated. Failures are reported per country in the run summary.
- The interface language is fixed to English (`en-US`), so category names are in English. Search terms stay in the local language.
- **If you publish this data, cite Google Trends as the source** (for example "Data source: Google Trends"), as Google asks for reused Trends data.
- A run of 45 countries usually finishes in 1 to 2 minutes.

### FAQ

**Do I need a Google account or an API key?**
No. The actor reads the public Trending Now list without logging in.

**Can I get the other Google Trends data (interest over time, by region, related queries for a keyword)?**
Not in this actor. It covers Trending Now only.

**How do I collect trends regularly?**
Create a schedule for the actor in Apify Console, or start it through the Apify API from your own code or from tools such as Make, Zapier or n8n.

**Is this legal?**
The actor collects aggregated, public trend lists, not personal data. You are responsible for how you use the data and for following the terms that apply to you. This actor is not affiliated with or endorsed by Google.

**Something looks wrong.**
Open an issue on the actor's Issues tab with the run ID. Include the countries and time window you used.

# Actor input Schema

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

Country codes (ISO 3166-1 alpha-2, e.g. US, KR, JP) or region codes (e.g. US-CA, JP-13). Up to 50 per run. All are collected in one run.

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

How far back trending searches are listed, in hours. Allowed values: 4, 24, 48 or 168 (7 days). Other values are rejected before any request.

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

Keep only trends in at least one of these categories. Leave empty for all categories.

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

Filter by whether the trend is still active.

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

Optional limit per country or region, applied after the filters in Google's original order. Leave empty for all.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "hours": 24,
  "categories": [],
  "status": "all"
}
```

# Actor output Schema

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

One row per trending search.

## `runSummary` (type: `string`):

Status per country or region, totals and stop reason.

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

// Run the Actor and wait for it to finish
const run = await client.actor("huggable_quote/google-trends-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 = { "countries": ["US"] }

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

```

## MCP server setup

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