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

Get Google Trends "Trending Now" searches for any country or region: up to 600+ live trending queries per geo with search volume, % growth, start/end time, category, breakdown keywords and related news articles. Many geos per run, 4h–7 day windows. No login, no browser, no start fee.

- **URL**: https://apify.com/scrapersdelight/google-trends-trending-now-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (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 $2.00 / 1,000 per trending search returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Trends Trending Now Scraper — Searches + News by Country

Turn the [Google Trends "Trending Now"](https://trends.google.com/trending) feed into a clean
table. One row per trending query per country or region: **query, geo, geoName, rank,
searchVolume, searchVolumeLabel, percentGrowth, startedAt, endedAt, isActive, activeHours,
categories, breakdownKeywords** and **newsArticles** (title, URL, source, published time, image).
Pick the window (4 h / 24 h / 48 h / 7 days), filter by category, status and volume, and pull
**many countries in one run**. No login. No browser. No CAPTCHA solving. No start fee.

**Scope: 606 trending searches for the US in the past 24 hours, 2,959 in the past 7 days** —
counted live off Google's own feed on 2026-08-22, not the 10-a-day the public RSS feed
publishes. Every one of the 25 fields was **100% filled on 100 live rows** (the only exception
is `endedAt`, which is `null` on purpose while a trend is still running — so it is filled on
only ~1–2% of a 24 h pull (nearly everything is still live) and on 93% of a 7-day pull).

```json
{
  "geos": ["US"],
  "hours": "24",
  "maxItems": 100,
  "includeNews": true
}
```

Click **Try for free** and hit **Start** — that is literally the input the Actor ships with. A
run on those shipped defaults returned **100 rows in under 10 seconds**, 100% of them with at
least one related news article (298 articles on 100 trends, every article with title, URL,
source, published time and image).

***

### The wedge: the whole feed, with news, for many countries, at one flat price

Google's Trending Now page is the fastest public signal of what people are searching for *right
now*, and it is the data behind every "trending keyword" dashboard, newsroom alert and
content-calendar tool. The public RSS feed only publishes **10 items per day per country** and
no volume numbers. The page itself lists **hundreds per country per day** with a search-volume
bucket, a growth percentage, the exact start time, a category, the "trend breakdown" keywords
and the news Google links to each trend — and that is what this Actor returns.

Measured against the other Trending Now Actors on the Store on 2026-08-22:

| | This Actor | Others |
|---|---|---|
| Rows per country per 24 h | **the whole list Google publishes — 457–606 for the US on repeat pulls** | 10/day (RSS-based Actors) |
| Countries per run | **as many as you list** — one request each | one `geo` string per run |
| Related news articles on the row | **yes**, title + URL + source + time + image | mostly no; one article or none |
| Growth %, category, breakdown keywords | **yes** | partial |
| Start fee | **none** | $0.005–$0.02 per run on the two nearest rivals |
| Price per row | $0.002 (+ $0.001 only when news is attached) | $0.001–$0.003 + start fee |

Two things only this row has:

- **`percentGrowth` + `searchVolume` together.** Google publishes both; a 1,000% growth on a
  2K+ bucket is a brand-new story, a 50% growth on a 500K+ bucket is a story that has already
  peaked. Sorting by either is an input option.
- **`breakdownKeywords`** — the "trend breakdown" list Google shows under a trend: the query
  variants people typed. The first entry is the headline query itself; on the measured 100 rows
  the median trend carried **2 keywords** and the mean was **4.1**, with the long tail running to
  42 on a big story.

***

### Read this before you buy rows

Five things that would otherwise turn into a refund request.

1. **`searchVolume` is a bucket, not a count.** Google publishes 100 / 200 / 500 / 1K / 2K / 5K /
   10K / 20K / 50K / 100K / 200K / 500K / 1M+ and nothing finer. `searchVolumeLabel` is the
   same number as Google prints it (`"100K+"`). Do not add buckets up and call it traffic.
2. **`percentGrowth` is Google's rounded figure** (50, 75, 100, 200 … 1000). 1000 means "1,000%
   or more" — it is capped, so every breakout trend reads 1000.
3. **A 7-day pull is big.** 2,959 rows for the US alone on 2026-08-22, 2,273 for GB. With
   `maxItems: 0` and twelve countries you are asking for 20,000+ rows. `maxItems` (default
   **100**) is your cost cap — set it deliberately.
4. **The same query can appear twice in a 7-day window** — as two different trends with two
   different `startedAt` times (a nightly sports fixture trends every evening). They are two
   rows with two `trendId`s, because Google counts them as two trends. Within one run a given
   `trendId` is never delivered twice.
5. **Category filtering is done here, not by Google.** Google's feed ignores the category
   parameter on the request (measured), so the Actor reads the category ids on every row and
   drops what you did not ask for **before billing** — filtered rows cost nothing, and the log
   tells you how many were dropped.

***

### What you get

One row per trending query per geo. Times are ISO-8601 UTC. `searchVolume` is an integer
bucket; `percentGrowth` is an integer percent.

| Group | Fields | Example |
|---|---|---|
| **Identity** | `trendId`, `query`, `normalizedQuery`, `rank` | `US:1787350200:blue jays vs yankees` · `blue jays vs yankees` · `1` |
| **Geo** | `geo`, `geoName` | `US` · `United States` |
| **Size** | `searchVolume`, `searchVolumeLabel`, `percentGrowth` | `100000` · `100K+` · `1000` |
| **Timing** | `startedAt`, `endedAt`, `isActive`, `activeHours` | `2026-08-21T22:10:00Z` · `null` · `true` · `19.4` |
| **Topic** | `categoryIds[]`, `categories[]`, `breakdownKeywords[]`, `breakdownKeywordCount` | `[17]` · `["Sports"]` · `["blue jays vs yankees","blue jays - yankees","mason fluharty"]` · `3` |
| **News** | `newsEnriched`, `newsArticleCount`, `newsArticles[]{title,url,source,publishedAt,imageUrl}` | `true` · `3` · CBS Sports / Sportsnet / Yahoo Sports |
| **Provenance** | `timeframeHours`, `language`, `trendsUrl`, `exploreUrl`, `scrapedAt` | `24` · `en-US` · link to the trend on Google Trends |

The dataset ships with a saved **table view** (*Trending searches*) so the Console shows rank,
query, geo, volume, growth, start time, status, categories and news count without any setup.

***

### Field fill — measured on 100 live rows

The shipped default (US, past 24 hours, 100 rows, news on), 2026-08-22 17:38 UTC. Sorted by fill.

| Field | Fill | Notes |
|---|---|---|
| `trendId` / `query` / `normalizedQuery` / `geo` / `geoName` / `rank` | 100% | |
| `searchVolume` / `searchVolumeLabel` | 100% | buckets on this pull: 1K+ 2 · 2K+ 14 · 5K+ 24 · 10K+ 22 · 20K+ 23 · 50K+ 3 · 100K+ 10 · 200K+ 2 |
| `percentGrowth` | 100% | |
| `startedAt` / `isActive` / `activeHours` | 100% | |
| `categoryIds` / `categories` | 100% | Sports 48 · Law and Government 16 · Entertainment 14 · Other 8 · Business and Finance 8 … |
| `breakdownKeywords` / `breakdownKeywordCount` | 100% | **median 2 keywords per trend**, mean 4.1 (one row carried 42) |
| `newsEnriched` / `newsArticleCount` / `newsArticles` | 100% | **2.98 articles per trend**; all 298 articles carried title, URL, source, publishedAt and imageUrl |
| `timeframeHours` / `language` / `trendsUrl` / `exploreUrl` / `scrapedAt` | 100% | |
| **`endedAt`** | **1%** | `null` = still trending. On a 7-day US pull (2,959 rows) it is filled on **93.4%** — 195 trends were still active |

**Every run prints its own measured fill in the log.** A 7-day, 12-country run under a short
time budget printed 5,229 rows at 100% on every field except `endedAt` (92.6%) and
`newsArticles` (56.2% — 2,269 rows had to skip news enrichment to stay inside the run's time
limit; give the run a longer timeout to get them).

***

### How to run it

#### 1. One country, past 24 hours (the shipped default)

```json
{ "geos": ["US"], "hours": "24", "maxItems": 100 }
```

#### 2. Many countries in one run

```json
{
  "geos": ["US", "GB", "CA", "AU", "IN", "DE", "FR", "BR", "JP", "MX"],
  "hours": "24",
  "maxItemsPerGeo": 50,
  "maxItems": 500,
  "sortBy": "volume"
}
```

Each geo is one request. `sortBy: "volume"` + `maxItemsPerGeo: 50` = the 50 biggest trends
in each of the ten countries. Regions work the same way: `"US-CA"`, `"US-NY"`, `"GB-ENG"`,
`"IN-MH"` — measured 2026-08-22: US-CA 250 rows / 24 h, 1,349 / 7 days.

#### 3. A category feed — e.g. Business + Technology, active only

```json
{
  "geos": ["US"],
  "hours": "48",
  "categories": ["3", "18"],
  "trendStatus": "active",
  "minSearchVolume": 10000,
  "maxItems": 0
}
```

Category ids (Google's own): 1 Autos and Vehicles · 2 Beauty and Fashion · 3 Business and
Finance · 20 Climate · 4 Entertainment · 5 Food and Drink · 6 Games · 7 Health · 8 Hobbies and
Leisure · 9 Jobs and Education · 10 Law and Government · 11 Other · 13 Pets and Animals ·
14 Politics · 15 Science · 16 Shopping · 17 Sports · 18 Technology · 19 Travel and
Transportation. Names are accepted too (`"Technology"`).

#### 4. The whole 7-day feed, no news (cheapest bulk pull)

```json
{ "geos": ["US"], "hours": "168", "includeNews": false, "maxItems": 0 }
```

\~3,000 rows at $0.002 = about $6. Turning news off removes the news event entirely; the
rows still carry every other field.

#### Daily cron feed

Save the input as a **Task** (Console → the Actor → *Save as Task*) and attach a **Schedule** —
`0 */4 * * *` for a 4-hour window every four hours gives you a continuous, deduplicated
trend log (any wider gap between runs than the window itself loses short-lived trends; dedupe
across runs on `trendId`). The dataset is available over the REST API and through the standard
Apify integrations (Zapier, Make, n8n, webhooks, MCP). Starting a run
from the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapersdelight~google-trends-trending-now-scraper/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"geos":["US","GB"],"hours":"4","maxItems":200}'
```

***

### Sample row

A real row from an actual run, captured 2026-08-22 17:32 UTC.

```jsonc
{
  "trendId": "US:1787350200:blue jays vs yankees",
  "query": "blue jays vs yankees",
  "normalizedQuery": "blue jays vs yankees",
  "geo": "US",
  "geoName": "United States",
  "rank": 1,
  "searchVolume": 100000,
  "searchVolumeLabel": "100K+",
  "percentGrowth": 1000,
  "startedAt": "2026-08-21T22:10:00.000Z",
  "endedAt": null,
  "isActive": true,
  "activeHours": 19.4,
  "categoryIds": [17],
  "categories": ["Sports"],
  "breakdownKeywords": ["blue jays vs yankees", "blue jays - yankees", "mason fluharty"],
  "breakdownKeywordCount": 3,
  "newsEnriched": true,
  "newsArticleCount": 3,
  "newsArticles": [
    {
      "title": "Yankees vs. Blue Jays prediction, odds, line, time: 2026 MLB picks for Saturday, Aug. 22 by proven model",
      "url": "https://www.cbssports.com/betting/news/yankees-blue-jays-prediction-odds-line-start-time-2026-mlb-picks-for-saturday-august-22/",
      "source": "CBS Sports",
      "publishedAt": "2026-08-22T16:07:55.000Z",
      "imageUrl": "https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcTR640lIFN8_MS0qBFEOvH_HgIiUMVi1eLKem6ZimIJmPBjvk4ab_nLX3AI_vc"
    },
    {
      "title": "Blue Jays left-hander Mason Fluharty to open game vs. Yankees on Friday",
      "url": "https://www.sportsnet.ca/mlb/article/blue-jays-left-hander-mason-fluharty-to-open-game-vs-yankees-on-friday/",
      "source": "Sportsnet.ca",
      "publishedAt": "2026-08-21T20:57:00.000Z",
      "imageUrl": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcTmalFI3Tgpj1H7cJ8cZejJ6JNltXXj0Fyn5h5oNaEAyqJC3tvB6LNrGgosp5s"
    },
    {
      "title": "Jays @ Yankees Game Thread",
      "url": "https://sports.yahoo.com/articles/jays-yankees-game-thread-143114881.html",
      "source": "Yahoo Sports",
      "publishedAt": "2026-08-22T14:31:14.000Z",
      "imageUrl": "https://encrypted-tbn3.gstatic.com/images?q=tbn:ANd9GcQ9S9UykDnFhvOSiqa4D727nJOpC2fldZSFNU9GjT2KSuWddRO-HF9MCstLjNg"
    }
  ],
  "timeframeHours": 24,
  "language": "en-US",
  "trendsUrl": "https://trends.google.com/trending?geo=US&hl=en-US&hours=24&q=blue%20jays%20vs%20yankees",
  "exploreUrl": "https://trends.google.com/trends/explore?q=blue%20jays%20vs%20yankees&geo=US&date=now%201-d&hl=en-US",
  "scrapedAt": "2026-08-22T17:32:18.239Z"
}
```

Fields people misread:

- `rank` is the position in **Google's own list** for that geo and window, recorded before any
  `sortBy` re-ordering — so a `sortBy: "volume"` dataset shows ranks like 214, 333, 171.
- `activeHours` is hours from `startedAt` to `endedAt`, or to now for an active trend.
- `trendId` is `geo:startEpoch:normalizedQuery` — stable across runs, use it to dedupe a
  scheduled feed.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `geos` | string list | `["US"]` | Country or region codes as Google Trends writes them (`US`, `GB`, `US-CA`). One request per geo. |
| `hours` | select | `"24"` | `4`, `24`, `48` or `168` — the four windows the page offers. |
| `categories` | multi-select | `[]` | Keep only trends in these categories (ids or names). Applied before billing. |
| `trendStatus` | select | `all` | `active` (no `endedAt`) · `ended` · `all`. |
| `minSearchVolume` | integer | `0` | Drop trends below this bucket. |
| `sortBy` | select | `default` | Google's order · search volume · most recent · growth %. Applied per geo before the caps. |
| `includeNews` | boolean | `true` | Attach related news articles. Off = no news event charged. |
| `maxNewsPerTrend` | integer | `3` | Cap articles per trend (max 10). Google's news lookup returns at most 3, so higher values change nothing. |
| `maxItems` | integer | `100` | **Your hard cost cap** across all geos. 0 = everything. |
| `maxItemsPerGeo` | integer | `0` | Per-geo cap so one big country does not use the whole budget. |
| `language` | string | `en-US` | Google Trends locale (`hl`) for geo names and linked-news language. |
| `proxyConfiguration` | proxy | Apify datacenter | Google Trends is not walled — the cheap rung is the default on purpose. |

***

### Pricing

**$0.002 per trending search returned — $2 per 1,000**, charged on the `trend-scraped` event.
**Plus $0.001 per row that actually receives news articles** (`news-articles-added`) — charged
only when at least one article came back, never when news is off or Google linked none. No
start fee. No monthly fee from this Actor.

| Run | Rows | Cost |
|---|---|---|
| The shipped default (US, 24 h, 100 rows, news on) | 100 | **$0.30** |
| Ten countries × top 50 by volume, news on | 500 | **$1.50** |
| US, full 7-day feed, news off | ~2,960 | **$5.92** |
| US, full 7-day feed, news on | ~2,960 | **$8.88** |

- **You are charged for rows delivered.** Rows removed by your category / status / volume
  filters, and rows dropped as duplicates, are never charged.
- **Rows are charged as they are pushed** (`Actor.pushData(items, 'trend-scraped')`), per geo,
  so a budget cap gives you whole rows and stops — never a half-billed dataset.
- **News is billed only where it ships.** If your run's charge limit leaves room for the trend
  rows but not their news, the Actor ships those rows *without* articles rather than shipping
  unbilled ones, and says so in the log.

***

### Honest limits

- **Volume is a bucket, growth is capped at 1000%.** That is all Google publishes; there is no
  finer number to get. If you need a real interest-over-time series for a keyword, that is the
  Google Trends *Explore* function — a different dataset, not this one.
- **Google decides how many trends a geo has.** Small markets are short: SE returned 115 rows
  for 24 h, ZA 135, AR 149, against 606 for the US. `maxItems` cannot raise a geo above what
  the feed holds; the log reports the raw count per geo.
- **No historical backfill.** The longest window is 7 days. Run it on a schedule and dedupe on
  `trendId` if you want a longer record.
- **An unknown geo code returns no rows, not an error.** A code Google does not know (`"UK"`) is
  requested and comes back empty with a warning (`UK: Google returned no trending rows … unknown
  geo code?`) before the run moves on to the next geo. A code that is not shaped like an ISO
  country/region code at all (`"USA"`) is dropped before the request — and if that leaves no
  valid geos the run falls back to `US` and says so in the log. Codes must be the ones Google
  Trends uses (`GB`, not `UK`).
- **News links are Google's picks** — 1 to 3 per trend, 3 on almost every enriched row (97 of
  100 on the live default run). A trend with no linked article ships with
  `newsArticleCount: 0` and is not charged the news event.
- **No login, no cookies, no CAPTCHA solving service.** Everything here is what the public
  Trending Now page itself requests.

***

### How it works, and what it cost to make reliable

The Trending Now page loads its list from one `batchexecute` RPC; this Actor calls the same RPC
with the same parameters (geo, language, window), reads the 13-slot rows it returns, and packs
the page's geo-name lookup into the same request — so one country is exactly one request. Related
news is a second RPC that accepts the article ids every row carries; up to 30 trends' worth are
packed into one request (measured 30/30 non-empty in 0.56 s). No HTML parsing, no browser, no
token to mint.

**Transport ladder, measured 2026-08-22 through Apify (fresh proxy session per request):**

| Rung | Trend feed | News batches |
|---|---|---|
| Direct, no proxy | 9/9 HTTP 200 | — |
| Apify proxy, datacenter | **20/20 geos, 5,880 rows** | **20/20 batches, 200/200 trends with articles** |
| Apify RESIDENTIAL + country US | 19/20 (one truncated read, not a block) | 19/19 |

**Google Trends is not walled on this surface** — no Cloudflare, no DataDome, no CAPTCHA on any
rung — so the default is the cheap datacenter rung. Sustained load: a single run made
**124 batchexecute requests in a row with 0 failures** (5,219 rows across the 2 geos it reached
inside the time budget, 122 news batches). `robots.txt` on trends.google.com disallows only
`/explore?` and `/trends/explore?`, which this Actor never requests (the `exploreUrl` in each
row is a link for you, not a fetch).

Reliability is built in from line one: a wall-clock budget derived from the run's own timeout
gates every request (nothing starts with under 8 s left), every request timeout is clamped to
the time remaining, crash nets turn an unforeseen error into a clean stop with a status message,
and a run that stops at its time or charge limit still delivers and bills every whole row it
collected — measured: 12 countries × 7 days under a ~100 s budget delivered 5,229 whole rows
from the first 2 geos and exited clean with the message *"Stopped early to stay inside this
run's time limit"*.

***

### Duplicates — measured

On a 7-day US pull of 2,959 rows the key `geo + startedAt + normalizedQuery` had **0
duplicates**, while plain `geo + query` had 181 — recurring fixtures and daily shows that trend
again each day. The Actor keys on the former, drops any repeat **before** it is pushed or billed,
and asserts uniqueness across everything it pushed before the run may succeed. Across runs use
`trendId` to dedupe your own store.

***

### When a run fails

- **0 rows** → exits cleanly with a status message naming the cause (every request failed /
  unknown geo codes / nothing matched your filters). Not a FAILED run, because a quiet hour in
  a small market is not an error.
- **A geo fails 3 attempts** → that geo is skipped with a warning; the run continues.
- **Duplicate leak** → the uniqueness assertion fails the run rather than shipping a dirty
  dataset.
- **Time limit** → delivers what it has, status message says so; raise the timeout or trim the
  geo list for the rest.

***

### Who buys this

- **SEO and content teams** — `breakdownKeywords` are the exact query variants to target while
  a topic is rising; `percentGrowth` + `searchVolume` say whether it is still rising.
- **Newsrooms and media monitoring** — the related-news links give a ready context for every
  trend, per country, on a 4-hour cadence.
- **Social and paid-media agencies** — category-filtered feeds (Shopping, Entertainment, Games)
  for reactive creative and ad copy.
- **Market and product research** — cross-country comparison of what is trending, with a
  consistent schema per geo.
- **AI agents and automations** — one call, flat rows, a stable `trendId`, pay per row.

***

### FAQ

**Does this need a Google account, a login or cookies?**
No. It requests the same public RPC the Trending Now page requests, logged out.

**How many rows does a country have?**
What Google lists: for the past 24 h on 2026-08-22 — US 606, GB 544, JP 515, DE 424, FR 356,
IN 308, BR 308, ES 289, CA 266, MX 232, PL 220, NL 216, KR 215, AU 178, AR 149, ZA 135, SE 115.
7 days is roughly 5× the 24 h number.

**Can I get interest-over-time for a keyword?**
No — that is the Explore function, a different dataset. This Actor is Trending Now only.

**Do I get charged for rows a filter removed?**
No. Category, status and volume filters run before billing.

**Will a run ever succeed with zero rows?**
Yes, cleanly, with a status message saying why. It will never end FAILED for an empty hour.

***

### Legal & fair use

This Actor reads the public Trending Now feed on trends.google.com without logging in and
without touching any path Google's `robots.txt` disallows. Rows are search queries and links to
publicly published news articles; they contain no personal data beyond what is in a public
search query. Google Trends is a trademark of Google LLC; this Actor is not affiliated with or
endorsed by Google. You are responsible for complying with Google's terms and with how you use
the data.

***

### Feedback

Found a missing field or want a new filter? Open an issue on the **Issues** tab, and if the
Actor earns it, a review on the **Reviews** tab helps other buyers find it.

# Actor input Schema

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

One or more ISO-3166 codes exactly as Google Trends uses them: a country ("US", "GB", "IN", "DE", "JP", "BR") or a region ("US-CA", "US-NY", "GB-ENG"). Every geo is one request and yields its own full trending list — measured 2026-08-22 at 24h: US 606, GB 544, JP 515, DE 424, US-CA 250, SE 115 rows.

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

The four windows the Trending Now page offers. Longer windows return more rows (US measured: 4h → 95, 24h → 606, 48h → 1,061, 7 days → 2,959).

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

Keep only trends Google tagged with at least one of these categories. Leave empty for all 19. Applied before billing — filtered rows cost nothing.

## `trendStatus` (type: `string`):

"Active" = Google has not marked the trend as ended (no endedAt). "Ended" = it has. Measured at 7 days for US: 195 of 2,959 active.

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

Drop trends below this search-volume bucket. Google's buckets are 100 / 200 / 500 / 1K / 2K / 5K / 10K / 20K / 50K / 100K / 200K / 500K / 1M+. 0 = keep everything.

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

"Google's order" is the order the Trending Now page lists them (rank is kept in every row regardless). The other options re-sort each geo before the caps are applied, so "Search volume" + maxItems 50 = the 50 biggest trends.

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

ON: fetches the news articles Google links to each trend (title, URL, source, published time, image) — charged as a separate news-articles-added event ONLY on rows that actually receive at least one article. OFF: rows ship with an empty newsArticles list and only the per-trend event is charged.

## `maxNewsPerTrend` (type: `integer`):

Cap how many articles are attached per trend. Google's news lookup returns at most 3 per trend (measured: 3 on every enriched row across 3,000+ rows), so values above 3 change nothing.

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

Your hard cost cap across all geos. 100 = $0.20 (+ up to $0.10 for news). Set 0 for everything the window holds — a 7-day US pull is ~3,000 rows.

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

Cap per country/region so one big geo does not use the whole budget. 0 = no per-geo cap.

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

Google Trends locale for category names, the geoName field and the language of linked news ("en-US", "en-GB", "de", "fr", "es", "pt-BR", "ja"). Queries themselves are always in the language people searched in.

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

Apify Proxy (datacenter) is the default and is enough — measured 20/20 geos + 20/20 news batches clean through the datacenter pool on 2026-08-22. RESIDENTIAL also works (19/20) but costs more per MB.

## Actor input object example

```json
{
  "geos": [
    "US"
  ],
  "hours": "24",
  "categories": [],
  "trendStatus": "all",
  "minSearchVolume": 0,
  "sortBy": "default",
  "includeNews": true,
  "maxNewsPerTrend": 3,
  "maxItems": 100,
  "maxItemsPerGeo": 0,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

The dataset of trending searches, one item per trending query per country (geo).

# 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"
    ],
    "maxItems": 100
};

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

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/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 '{
  "geos": [
    "US"
  ],
  "maxItems": 100
}' |
apify call scrapersdelight/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,scrapersdelight/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/flv5Xm4BU1vHszBwc/builds/03eog3KDcBpIK8bzj/openapi.json