# Google Trends Trending Now API — Real-Time Trending Searches (`insanedev/google-trends-trending-now`) Actor

Real-time trending searches from Google Trends (Trending Now, which replaced Daily and Realtime Search Trends) for 125 countries & US states in one run: search volume, growth, start/end, related searches, categories & news. Only-new mode for alerts. Pay per trend.

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

## Pricing

from $0.40 / 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.
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 API** gets **every trending search** from [Google Trends Trending Now](https://trends.google.com/trending) — not just the 10 items of the RSS feed — for **125 countries and US states/regions in one run**. Each trend comes with its **search volume, growth %, start and end time, related searches, categories and the news behind it**. Schedule it hourly with **"Only new trends"** and get a clean feed of what just started trending — no repeats.

- 📈 **Full lists** — 400+ trends for the US in 24 hours, ~5,600 across all countries, exactly what Google's page shows.
- 📰 **News for every trend** — headline, link, source, time and image (up to 20 articles per trend), included in the price.
- 🌍 **Many countries per run** — pick countries, all 125 at once, or states and regions like `US-CA`, `GB-ENG`, `DE-BY`.
- 🔔 **Only new trends** — hourly schedules deliver just the trends you haven't received yet, so you pay for new ones only.
- ⚡ **Fast** — the US in ~7 seconds, all countries in under 2 minutes, 256 MB memory, no browser.
- 💸 **Pay per trend** — from **$1 per 1,000 trends**, no start fee; failures and empty regions are free.

### What data does Google Trends Trending Now give you?

For every trending search in the countries and time window you choose:

| Field | Example | What it means |
|---|---|---|
| `trendId` | `US:rams vs broncos:1790541600` | Stable id of this trend (the same search can trend twice in a week) |
| `trend` | `rams vs broncos` | The trending search |
| `geo`, `geoName` | `US`, `United States` | Country or region |
| `rank` | `1` | Position in Google's own order |
| `searchVolume`, `searchVolumeLabel` | `1000000`, `1M+` | Searches within the window (Google's bucket) |
| `growthPercent` | `1000` | Increase vs. normal (Google caps it at 1,000%) |
| `isActive`, `startedAt`, `endedAt`, `durationMinutes` | `true`, `2026-09-27T20:40:00Z` | Is it still trending, since when, for how long |
| `categories` | `["Sports"]` | Google's categories (Sports, Politics, Entertainment, …) |
| `relatedQueries` | `["rams", "broncos", "bo nix", …]` | Searches that make up the trend (Google's "trend breakdown") |
| `news` | `[{ title, url, source, publishedAt, imageUrl }]` | Articles behind the trend |
| `topNewsTitle`, `topNewsUrl`, `topNewsSource`, `imageUrl` | | First article, flat — handy for Sheets and Slack |
| `countriesTrending`, `trendingInCountries` | `3`, `["US","CA","MX"]` | Where else the same search trends in this run |
| `isNew`, `firstSeenAt` | `true` | With "Only new trends" |
| `trendsUrl`, `exploreUrl` | | Google's Trending Now page and Explore for the trend |

### Why use this Trending Now API instead of other scrapers?

Same task for every tool — **United States, past 24 hours, all trends** — run on Apify on 2026-09-28:

| | **This Actor** | Full-list scraper A | Full-list scraper B | RSS-based scrapers (3 tested) |
|---|---|---|---|---|
| Trends returned | **417** | 417 | 417 | 10 (the newest, ranks 30–165 of Google's list) |
| Trends with news | **415** | 10 | 0 | 10 |
| Growth %, start/end, active | ✅ | ✅ | no growth % | ❌ |
| Categories, related searches | ✅ | ✅ | ✅ | ❌ |
| Many countries in one run | ✅ 125 + regions | ❌ | ❌ | ❌ |
| "Only new" mode for schedules | ✅ no repeats | ⚠️ half of "new" were repeats\* | ❌ | ❌ |
| Time | **7 s** | 46 s | 8 s | 4–85 s |
| Price of this run | **$0.42** ($0.33 on paid plans) | $0.63 | $0.44 ($0.33 on paid plans) | $0.002–0.035 for 10 trends |

\* Google regroups searches between fetches: a search listed inside one trend ("rams schedule" in "rams vs broncos") can appear as a trend of its own an hour later. Monitoring that only compares titles sends it to you again. In our test (United Kingdom, two runs one hour apart) both tools found the same 7 trends that had just started; scraper A also re-sent 9 searches it had already delivered inside other trends — 9 of its 18 "new" alerts. This Actor remembers the searches inside every trend it delivered and sent 0 repeats.

### How to get Google Trends trending searches

1. Click **Try for free** (or **Start**).
2. Pick one or more **Countries** — or tick **All countries** — and optionally add **States and regions** such as `US-CA`.
3. Choose the **Time window** (past 4 hours, 24 hours, 48 hours or 7 days, or any 1–191 hours).
4. Optionally filter by **Categories**, **Active trends only**, **Minimum search volume** or words (**Only trends mentioning**).
5. Click **Start** and download the trends as **JSON, CSV, Excel or HTML**, or send them to Google Sheets, Slack, Make, Zapier or n8n.

#### Get alerts for new trends every hour

1. Set your countries and filters (for example *Sports* in the US, or trends mentioning your brand).
2. Tick **Only new trends** and **Save as a new task**.
3. Add a **Schedule** (for example every hour) and an **Integration** (Slack, e-mail, webhook, Google Sheets).
4. Optional: enter a name in **Also save to dataset** — every run appends its new trends there, so you build your own Trending Now history (Google itself keeps only about 8 days).

Every run delivers only trends that earlier runs of this task haven't delivered — in our test, the second hourly run for the United Kingdom delivered 9 new trends (about $0.01).

### Input example

```json
{
    "countries": ["US", "GB", "DE"],
    "regions": ["US-CA"],
    "timeWindow": "24",
    "newsPerTrend": 3,
    "categories": ["sports", "politics"],
    "activeOnly": false,
    "onlyNew": false
}
```

All fields are on the **Input** tab with descriptions. Leave **Countries** empty to get the US.

### Output example

```json
{
    "trendId": "US:rams vs broncos:1790541600",
    "trend": "rams vs broncos",
    "geo": "US",
    "geoName": "United States",
    "rank": 1,
    "timeWindowHours": 24,
    "searchVolume": 1000000,
    "searchVolumeLabel": "1M+",
    "growthPercent": 1000,
    "isActive": true,
    "startedAt": "2026-09-27T20:40:00.000Z",
    "endedAt": null,
    "durationMinutes": 1161,
    "categories": ["Sports"],
    "relatedQueries": ["rams vs broncos", "rams", "broncos", "denver broncos", "bo nix", "sean payton"],
    "articleCount": 72,
    "news": [
        {
            "title": "After Broncos' latest comeback, Payton pushes for stronger starts",
            "url": "https://www.espn.com/nfl/story/_/id/50050195/after-broncos-latest-comeback-payton-pushes-stronger-starts",
            "source": "ESPN",
            "publishedAt": "2026-09-28T06:22:00.000Z",
            "imageUrl": "https://encrypted-tbn2.gstatic.com/images?q=tbn:…"
        }
    ],
    "topNewsTitle": "After Broncos' latest comeback, Payton pushes for stronger starts",
    "topNewsUrl": "https://www.espn.com/nfl/story/_/id/50050195/after-broncos-latest-comeback-payton-pushes-stronger-starts",
    "topNewsSource": "ESPN",
    "countriesTrending": 1,
    "trendingInCountries": ["US"],
    "isNew": null,
    "firstSeenAt": null,
    "trendsUrl": "https://trends.google.com/trending?geo=US&hours=24",
    "exploreUrl": "https://trends.google.com/trends/explore?q=rams%20vs%20broncos&geo=US&date=now%207-d",
    "scrapedAt": "2026-09-28T16:01:02.000Z"
}
```

The **Trends** view shows the main columns; **Spreadsheet** has flat columns for CSV/Excel. The run's `SUMMARY` record lists, per country/region, how many trends Google returned, matched your filters and were delivered.

### Which countries, states and regions are covered?

**All 125 countries** Google Trends publishes Trending Now for, plus **1,013 states and regions in 43 countries** (we
requested every one of the 3,130 sub-region codes Google Trends knows on 2026-09-28; these are the ones with a list).
Use the codes in **States and regions**:

| Country | Regions | Examples |
|---|---|---|
| RU | 83 | `RU-AD` Adygea, `RU-AL` Altai Republic, `RU-ALT` Altai Krai |
| TR | 81 | `TR-01` Adana, `TR-02` Adıyaman Province, `TR-03` Afyonkarahisar Province |
| VN | 63 | `VN-01` Lai Chau, `VN-02` Lao Cai, `VN-03` Ha Giang |
| US | 51 | `US-AK` Alaska, `US-AL` Alabama, `US-AR` Arkansas |
| JP | 47 | `JP-01` Hokkaido Prefecture, `JP-02` Aomori Prefecture, `JP-03` Iwate Prefecture |
| NG | 37 | `NG-AB` Abia, `NG-AD` Adamawa, `NG-AK` Akwa Ibom |
| IN | 36 | `IN-AN` Andaman and Nicobar Islands, `IN-AP` Andhra Pradesh, `IN-AR` Arunachal Pradesh |
| ID | 34 | `ID-AC` Aceh, `ID-BA` Bali, `ID-BB` Bangka Belitung Islands |
| CO | 33 | `CO-AMA` Amazonas Department, `CO-ANT` Antioquia, `CO-ARA` Arauca |
| MX | 32 | `MX-AGU` Aguascalientes, `MX-BCN` Baja California, `MX-BCS` Baja California Sur |
| BR | 27 | `BR-AC` State of Acre, `BR-AL` State of Alagoas, `BR-AM` State of Amazonas |
| EG | 27 | `EG-ALX` Alexandria Governorate, `EG-ASN` Aswan Governorate, `EG-AST` Assiut Governorate |
| UA | 27 | `UA-05` Vinnyts'ka oblast, `UA-07` Volyns'ka oblast, `UA-09` Luhans'ka oblast |
| CH | 26 | `CH-AG` Aargau, `CH-AI` Appenzell Innerrhoden, `CH-AR` Appenzell Outer Rhodes |
| PE | 25 | `PE-AMA` Amazonas, `PE-ANC` Ancash, `PE-APU` Apurimac |
| AR | 24 | `AR-A` Salta Province, `AR-B` Buenos Aires Province, `AR-C` Autonomous City of Buenos Aires |
| EC | 24 | `EC-A` Azuay, `EC-B` Bolívar Province, `EC-C` Carchi Province |
| FR | 22 | `FR-A` Alsace, `FR-B` Aquitaine, `FR-C` Auvergne |
| SE | 21 | `SE-AB` Stockholm County, `SE-AC` Västerbotten County, `SE-BD` Norrbotten County |
| IT | 20 | `IT-21` Piedmont, `IT-23` Aosta, `IT-25` Lombardy |
| PT | 20 | `PT-01` Aveiro District, `PT-02` Beja District, `PT-03` Braga |
| ES | 19 | `ES-AN` Andalusia, `ES-AR` Aragon, `ES-AS` Asturias |
| UY | 19 | `UY-AR` Artigas Department, `UY-CA` Canelones Department, `UY-CL` Cerro Largo Department |
| PH | 17 | `PH-00` Metro Manila, `PH-01` Ilocos Region, `PH-02` Cagayan Valley |
| DE | 16 | `DE-BB` Brandenburg, `DE-BE` Berlin, `DE-BW` Baden-Württemberg |
| KR | 16 | `KR-11` Seoul, `KR-26` Busan, `KR-27` Daegu |
| MY | 16 | `MY-01` Johor, `MY-02` Kedah, `MY-03` Kelantan |
| NZ | 16 | `NZ-AUK` Auckland, `NZ-BOP` Bay Of Plenty, `NZ-CAN` Canterbury |
| PL | 16 | `PL-DS` Lower Silesian Voivodeship, `PL-KP` Kuyavian-Pomeranian Voivodeship, `PL-LB` Lubusz Voivodeship |
| CL | 15 | `CL-AI` XI Región, `CL-AN` Antofagasta Region, `CL-AP` Arica y Parinacota Region |
| CA | 13 | `CA-AB` Alberta, `CA-BC` British Columbia, `CA-MB` Manitoba |
| SA | 13 | `SA-01` Riyadh Province, `SA-02` Makkah Province, `SA-03` Al Madinah Province |
| NL | 12 | `NL-DR` Drenthe, `NL-FL` Flevoland, `NL-FR` Friesland |
| AT | 9 | `AT-1` Burgenland, `AT-2` Carinthia, `AT-3` Lower Austria |
| ZA | 9 | `ZA-EC` Eastern Cape, `ZA-FS` Free State, `ZA-GT` Gauteng |
| AU | 8 | `AU-ACT` Australian Capital Territory, `AU-NSW` New South Wales, `AU-NT` Northern Territory |
| PK | 8 | `PK-BA` Balochistan, `PK-GB` Gilgit-Baltistan, `PK-IS` Islamabad Capital Territory |
| AE | 7 | `AE-AJ` Ajman, `AE-AZ` Abu Dhabi, `AE-DU` Dubai |
| IL | 6 | `IL-D` South District, `IL-HA` Haifa District, `IL-JM` Jerusalem District |
| TW | 6 | `TW-KHH` Kaohsiung City, `TW-TAO` Taoyuan City, `TW-TNN` Tainan City |
| DK | 5 | `DK-81` North Denmark Region, `DK-82` Central Denmark Region, `DK-83` Region Syddanmark |
| GB | 4 | `GB-ENG` England, `GB-NIR` Northern Ireland, `GB-SCT` Scotland |
| BE | 3 | `BE-BRU` Brussels, `BE-VLG` Flanders, `BE-WAL` Walloon Region |

Region codes are Google's: mostly ISO 3166-2 (`US-TX`, `DE-BE`), but some countries use older codes (France: letters, `FR-J` = Île-de-France). A code without a list is reported in the run summary and costs nothing.

### How much does the Google Trends Trending Now API cost?

You pay per trend delivered (one dataset row). Failed requests, regions without a list and trends your filters skip are free.

| Apify plan | Price per 1,000 trends |
|---|---|
| Free | $1.00 |
| Starter | $0.80 |
| Scale | $0.60 |
| Business | $0.40 |

Examples (Free plan):

- **US, past 24 hours, all trends** (~420): about **$0.42**.
- **US, top 50 trends**: $0.05.
- **All 125 countries, past 24 hours** (~5,600): about $5.60.
- **Hourly US alerts with "Only new trends"**: you pay only for trends that are new since the last run.

Set **Max trends per country/region** or the run's maximum cost to cap spending. If the limit can't cover every trend, you get **the top trends of every region** (rank by rank across all regions) instead of complete lists for the first few — and the run tells you how many it left out. The biggest possible run — all 125 countries, past 7 days — is about 29,000 trends (~$29 on the Free plan); raise *Maximum cost per run* in the run options for it.

### Use it as an API (Python, JavaScript, cURL)

Every run is available through the [Apify API](https://docs.apify.com/api/v2). Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("insanedev/google-trends-trending-now").call(run_input={"countries": ["US", "GB"], "timeWindow": "4"})
for trend in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(trend["geo"], trend["trend"], trend["searchVolumeLabel"], trend["topNewsTitle"])
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('insanedev/google-trends-trending-now').call({ countries: ['US'], categories: ['technology'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

cURL (runs the Actor and returns the trends in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/insanedev~google-trends-trending-now/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d '{"countries":["US"],"maxTrendsPerRegion":20}'
```

AI agents can call it through the [Apify MCP server](https://mcp.apify.com).

### Tips

- **Need history for a trend?** Paste it into our [Google Trends API & Scraper](https://apify.com/insanedev/google-trends-scraper) for interest over time (up to 20 years, daily data), regions, cities and related queries.
- **Past 4 hours + Only new trends** on an hourly schedule is the cheapest way to catch trends early.
- **Watch a brand or topic:** put words into **Only trends mentioning** — it also checks each trend's related searches, with accents and case ignored.
- **Many countries:** trends that appear in several countries have `countriesTrending` > 1 — sort by it to find global stories.
- **No news needed?** Set **News articles per trend** to 0 for the fastest runs (the price is the same).

### FAQ

**Why do a few trends have no news?** Google stops returning articles for some trends after they end — about 2% of all trends in our tests, mostly in Taiwan and Japan. `articleCount` still shows how many articles Google had linked; asking again doesn't bring them back.

**Where does the data come from?** From Google Trends' public Trending Now page — the same list, numbers and news you see at trends.google.com/trending. No Google account is used.

**What happened to Google Trends Daily Search Trends and Realtime Search Trends?** Google replaced both with Trending Now, and the old pages and endpoints (`/trends/trendingsearches/daily`, `/trends/hottrends`) now redirect to trends.google.com/trending. This Actor returns that list, so you can use it as a Google Trends realtime and daily trends API: run it every hour with **Past 4 hours** and **Only new trends** for a real-time feed, or once a day with **Past 24 hours** for a daily list.

**How far back can I go?** Google keeps about 8 days (191 hours) of Trending Now. To keep more, schedule the Actor with **Only new trends** and **Also save to dataset**: the named dataset keeps growing run after run. For the long-term interest of a specific search, use [Google Trends API & Scraper](https://apify.com/insanedev/google-trends-scraper).

**Why is the search volume a range like "200K+"?** Google publishes volume in buckets (100+, 200+, 500+, 1K+, … 1M+). `searchVolume` is the bucket's lower bound as a number.

**Why do some regions return nothing?** Google publishes Trending Now for 125 countries and many sub-regions, but not for every code (for example `FR-IDF`). Such regions are listed in the run summary and cost nothing.

**Is it legal to scrape Google Trends?** The Actor reads public, aggregated data that Google shows to every visitor, without logging in. You are responsible for how you use the data; check the laws and terms that apply to you.

**Something missing or broken?** Open an issue on the **Issues** tab. Need a custom feed, archive or integration? Ask there too.

# Changelog

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

# Actor input Schema

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

Countries to get Trending Now for (125 available). Each country is fetched in full — every trend Google lists, not just the top 10 of the RSS feed.

## `allCountries` (type: `boolean`):

Fetch all 125 countries in one run (≈ 5,000 trends for the past 24 hours).

## `regions` (type: `array`):

States and regions by code — Google publishes Trending Now for 1,013 of them in 43 countries: all US states (`US-CA`, `US-NY`, …), `GB-ENG`/`GB-SCT`/`GB-WLS`/`GB-NIR`, German states (`DE-BY`), Canadian provinces (`CA-ON`), Indian states (`IN-MH`), Japanese prefectures (`JP-13` = Tokyo), French regions (letter codes: `FR-J` = Île-de-France), and more (see README). Country codes work here too. Codes without a list are listed in the run summary and cost nothing.

## `timeWindow` (type: `string`):

Trends that started within this window, like the time filter on Google's Trending Now page.

## `customHours` (type: `integer`):

Any window from 1 to 191 hours (Google keeps about 8 days). Overrides the time window above.

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

Headlines, links, sources and images of the news behind each trend (0–20). Included in the price.

## `maxTrendsPerRegion` (type: `integer`):

Stop after this many trends per country or region (after filters and sorting). Leave empty or 0 for all of them — the US alone has 400+ trends in 24 hours.

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

Keep only trends in these categories (a trend can be in several). Empty = all categories.

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

Skip trends that have already ended (Google's "Active trends only" switch).

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

Skip trends below this search volume (Google's buckets: 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000+).

## `includeKeywords` (type: `array`):

Watchlist: keep a trend only if it or one of its related searches contains any of these words (case and accents ignored), e.g. your brand or competitors.

## `excludeKeywords` (type: `array`):

Skip trends containing any of these words (case and accents ignored).

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

Order of trends within each country/region.

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

Deliver only trends that previous runs have not delivered yet (plus trends that ended and started trending again). Ideal for hourly schedules and Slack/e-mail alerts — you pay only for new trends. Each saved task keeps its own memory.

## `monitoringKey` (type: `string`):

Optional name for the memory of "Only new trends" when you run the Actor via API without a saved task. Runs with the same key share what was already delivered.

## `outputDatasetName` (type: `string`):

Name of a dataset every delivered trend is also appended to (created on the first run, kept after the run's own data expires). With a schedule and "Only new trends" this builds your own Trending Now history — Google keeps only about 8 days.

## `strictStatus` (type: `boolean`):

Fail the run when more than half of the countries/regions fail (for uptime monitoring).

## Actor input object example

```json
{
  "countries": [
    "US",
    "GB",
    "DE"
  ],
  "allCountries": false,
  "regions": [
    "US-CA",
    "GB-ENG",
    "DE-BY",
    "FR-J"
  ],
  "timeWindow": "24",
  "newsPerTrend": 3,
  "maxTrendsPerRegion": 50,
  "categories": [
    "sports",
    "politics"
  ],
  "activeOnly": false,
  "minSearchVolume": 0,
  "includeKeywords": [
    "iphone",
    "samsung"
  ],
  "excludeKeywords": [
    "weather"
  ],
  "sortBy": "relevance",
  "onlyNew": false,
  "monitoringKey": "newsroom-us",
  "outputDatasetName": "trending-now-history",
  "strictStatus": false
}
```

# Actor output Schema

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

Trending searches with volume, growth, categories and the top news.

## `allData` (type: `string`):

Full rows including all news articles.

## `summary` (type: `string`):

Per country/region: trends from Google, matched, delivered, failures; billed trends.

# 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"
    ],
    "maxTrendsPerRegion": 50
};

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

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

```

## MCP server setup

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