# Google Trends Scraper — Trending Searches, Traffic, Queries (`architekture/google-trends-scraper`) Actor

Google Trends Trending Now searches by country from trends.google.com: title, approximate traffic, start time, active flag and related queries. Filter by country, 4-hour to 7-day window and category; watch mode delivers only new trends. Free preview. Pay per result, no login.

- **URL**: https://apify.com/architekture/google-trends-scraper.md
- **Developed by:** [architek.earth](https://apify.com/architekture) (community)
- **Categories:** SEO tools, AI, 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 delivered trending now rows

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

## Google Trends Scraper — Trending Searches, Traffic, Queries

**Recorded run: 10 trends from 1 country in 15 seconds** (2026-10-22, build 0.1.10, run `RCvNLNtBM67sTa1Vf`). A bounded canary sample, not a full-catalogue benchmark.

architek.earth — an independent data studio. Pay-per-result scrapers with recorded runs, published canaries and stable schemas, built for people and AI agents.

Google Trends trending searches by country: give it a country code, a time window and an optional category, and get back each Trending Now search with its approximate traffic, start time, active flag and related queries from trends.google.com.

| Source | Market | From | Standout fields |
|---|---|---|---|
| Google Trends Trending Now (trends.google.com/trending) | Countries Google lists in Trending Now (US, GB and AU tested) | $1.00 / 1,000 trends | `title`, `approxTraffic`, `startedAt`, `relatedQueries` |

### ✅ Why choose this scraper

#### Google trending searches by country, with traffic

Every row carries `title`, `approxTraffic` (Google's displayed threshold, for example `500000` for 500K+), `startedAt` in UTC and `isActive`.

#### Filter Google Trends by time window and category

`hours` takes 4, 24, 48 or 168 (7 days), matching Google's "started trending within" control; `category` takes one of 19 Trending Now category IDs, such as 17 for Sports.

#### Related queries for each trending search

`relatedQueries` holds Google's breakdown of the trend; the sample row below came with 32 queries.

#### Alerts for new Google trends only

With `incrementalMode` and a `stateKey`, a run delivers only trends not seen before under that key, identified by country, title and start time. The watch canary delivered 3 new automotive trends on 2026-10-22 (run `di6kqI4IyhKSVlK4N`) and none, at no charge, on 2026-10-21 (run `rCijZ1auZYWPedBoR`).

#### Measured on a schedule

A canary task collects 10 US trends from the 24-hour list every day; the hero line above is its latest green run.

### ⚠️ Worth knowing up front

- Trending Now only. Interest over time, interest by region, related topics and the Explore related-queries report for your own keywords are not included; keyword mode is on hold. `relatedQueries` is Google's breakdown of a trending search, not the Explore report.
- Coverage is the countries Google publishes in Trending Now. US, GB and AU returned rows on 2026-10-22. A country code Google does not list is not swapped for another: run `p7yo6VobvGEP24wMB` with `ZZ` ended `PARTIAL` with a free `SOURCE_CHANGED` status row and no charge.
- `approxTraffic` is Google's approximate traffic threshold (100,000 for a displayed 100K+), not an exact search count and not the Explore 0–100 index.
- `newsLinks` is always an empty array. The page Google serves carries article identifiers, not article URLs, and the actor does not invent links.
- `hours` means "started trending within" that period, as on Google's page. The list and the traffic figures change between requests.
- The page is fetched with up to 3 attempts, 3 seconds apart at least, backing off on HTTP 429 and 5xx. An empty result is fetched a second time before it is reported as `NO_DATA`. A page that is still blocked, rate-limited, unavailable or changed writes a free status row and the run ends `PARTIAL` with nothing charged.
- A run stops cleanly 2 minutes before its deadline (`PARTIAL`, `stopReason` `ACTOR_DEADLINE`) and at your spending limit (`BUDGET_LIMIT`), keeping what it delivered. The deadline is the run timeout, capped at 6 hours, including runs with no timeout. Reaching `maxItems` ends the run `LIMITED`.
- A free status row (`"recordType": "status"`) is written for invalid input (`INVALID_INPUT`), a used-up preview allowance (`PREVIEW_LIMIT`), a `stateKey` in use by another run (`STATE_BUSY`), and a fetch that fails or finds nothing (`BLOCKED`, `RATE_LIMITED`, `SOURCE_UNAVAILABLE`, `SOURCE_CHANGED`, `NOT_FOUND`, `NO_DATA`). A spending-limit, deadline or `maxItems` stop writes no status row; the outcome is in `RUN_SUMMARY`. A storage fault or an unconfirmed delivery (`RECONCILIATION_REQUIRED`) fails the run and replays nothing.
- With a `stateKey` outside watch mode, a run that stops before the end of the list leaves a saved snapshot; the next run with that key must set `continuePreviousRun: true` or use a new key, otherwise it ends with `INVALID_INPUT`. Changing country, window, category, watch mode or billing mode under an existing key is also rejected.

### ⚡ Try the example

Free preview: 20 lifetime runs per Apify account, up to 10 trends each, with `"billingMode": "preview"`. A preview run uses one of the 20 as soon as it starts, even if the source then fails, and never switches to paid. The paid example below costs $0.01.

Open the actor's input page, switch to JSON, paste this and start the run:

```json
{
  "mode": "trending",
  "geo": "US",
  "hours": 24,
  "category": 0,
  "maxItems": 10,
  "billingMode": "paid"
}
```

Change `geo` to another country code, raise `maxItems` for the full list, or set `category` to one ID from the list below.

### ⚙️ Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `trending` | The only mode in this version. |
| `geo` | string | `US` | Two-letter uppercase country code that Google lists in Trending Now, for example `US`, `GB`, `AU`. |
| `hours` | integer | `24` | `4`, `24`, `48` or `168` (7 days): trends that started within that period. |
| `category` | integer | `0` | Trending Now category ID; `0` is all categories. These are not Explore category IDs. |
| `maxItems` | integer | `100` (prefill `10`) | 1–10,000 delivered rows per run; preview runs are capped at 10. |
| `billingMode` | select | `preview` (prefill `paid`) | `paid` charges per delivered trend; `preview` uses the free allowance. |
| `incrementalMode` | boolean | `false` | Needs `stateKey`. Delivers only trends whose country, title and start time are new to that key. |
| `stateKey` | string | — | Any name up to 100 characters, for example `us-daily`. Keeps the watch baseline and saved progress, isolated per account and key. Use a different key for different filters. |
| `continuePreviousRun` | boolean | `false` | Needs `stateKey`. Resumes an unfinished saved snapshot instead of fetching a new one. Watch mode resumes its backlog without it. |
| `proxyConfiguration` | proxy | — | Optional Apify proxy. No proxy is used by default. |
| `feedback` | string | — | Optional note for the maintainers. It is logged and read by a human, and it never changes output. |

Category IDs: 1 Autos and Vehicles, 2 Beauty and Fashion, 3 Business and Finance, 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, 20 Climate.

### 🧱 Stable fields

These top-level fields keep the same name and the same kind of value in every release. Fields are only ever added, never renamed or removed, so an n8n, Make, Zapier or spreadsheet pipeline can bind to them.

| Field | Type | Meaning |
|---|---|---|
| `geo` | string | Requested country code, checked against the country on every source row. |
| `title` | string | Trending search as Google publishes it. |
| `approxTraffic` | number | Approximate traffic threshold published by Google (integer). |
| `startedAt` | string | When the trend started, UTC ISO 8601. |
| `isActive` | boolean | `true` when Google shows no end time for the trend. |
| `relatedQueries` | array | Google's breakdown of the trend, as strings. |
| `newsLinks` | array | Always empty in this version; article URLs are not collected. |
| `scrapedAt` | string | Collection time, UTC ISO 8601. |
| `recordType` | string | `"status"` on free status rows; `"trending"` on data rows. |

Data rows also carry `deliveryId` (unique per delivered row) and, in watch mode, `changeType: "new"`. Status rows carry `recordType`, `inputRef`, `status`, `message` and, for fetch outcomes, `mode`. Other fields are extras, not part of the contract. To have one pinned, say so in `feedback`.

### 📦 Output example

Abridged real row from run `RCvNLNtBM67sTa1Vf` on 2026-10-22; values are a historical snapshot.

```json
{
  "recordType": "trending",
  "geo": "US",
  "title": "warriors vs lakers",
  "approxTraffic": 500000,
  "startedAt": "2026-10-22T01:00:00+00:00",
  "isActive": true,
  "relatedQueries": [
    "warriors vs lakers",
    "lakers",
    "warriors",
    "lakers vs warriors",
    "luka doncic"
  ],
  "newsLinks": [],
  "scrapedAt": "2026-10-22T07:10:14.534598+00:00",
  "deliveryId": "8f0b4983d6003332eb8440a7ef8f591f70945a775de833d2aef0a9cf0b7b3a3c"
}
```

A free status row looks like this (run `p7yo6VobvGEP24wMB`, 2026-10-21, country code `ZZ`):

```json
{"recordType": "status", "mode": "trending", "inputRef": "ZZ", "status": "SOURCE_CHANGED", "message": "Unexpected Trending Now response structure"}
```

The run's status message reads `Done: N rows, M details, K status rows (STATUS)`, and the `RUN_SUMMARY` record of its key-value store holds the outcome (abridged, same run as the row above):

```json
{
  "status": "LIMITED",
  "delivered": 10,
  "charged": {"trending-row": 10, "keyword-report": 0},
  "statusRows": 0,
  "errors": 0,
  "blocked": 0,
  "unchanged": 0,
  "recoveredUncertainCharges": 0,
  "chargeUsd": "0.010",
  "checkpointComplete": false
}
```

### 🧠 Advanced usage

#### Get new Google trends every day for one country

Schedule `"incrementalMode": true`, `"stateKey": "us-daily"`, `"billingMode": "paid"` and a `maxItems` that fits your budget. The first run sets the baseline from the rows it delivers; later runs deliver only unseen trends, each with `changeType: "new"`. A recurring topic with a new start time counts as a new trend. Check `RUN_SUMMARY.status` and `checkpointComplete` before treating a poll as finished.

#### Track one Google Trends category, such as Sports

Use `"category": 17` with its own `stateKey`. Google filters categories in the browser, so the actor applies the same category IDs to the rows it reads; one key per country, window and category.

#### Collect a full Google Trends country list over several runs

With a `stateKey`, a run that stops at `maxItems`, the spending limit or the deadline keeps a saved snapshot. Run again with `"continuePreviousRun": true` to deliver the rest of the same snapshot; in watch mode the next identical run drains the backlog before fetching fresh data, so a small `maxItems` can delay fresh polls.

#### Join Google trends to your own news or social data

Join on `title` and `geo`, and use `startedAt` and `isActive` to window the match. `approxTraffic` is an attention signal, not evidence of purchase intent.

### 🔌 Integrations

Results land in a dataset you can export as JSON, CSV or Excel. They can also flow to Google Sheets, Make, Zapier or n8n, or to a webhook when a run finishes. The Apify Scheduler runs it on a timetable. An hourly or daily watch run with `incrementalMode` turns the 4-hour or 24-hour list into a feed of new trends; use paid mode for schedules so the preview allowance does not stop them. Copy-paste code in Python, Node, curl and n8n: [architek-earth/examples/google-trends-scraper](https://github.com/architek-earth/examples/tree/main/google-trends-scraper).

### 💸 Pricing

Pay per result. Platform and proxy usage are included. Status rows and failed requests are free. Each trend is charged once, after it is written to the dataset; `continuePreviousRun` resumes after the last confirmed row, a row whose charge was left unconfirmed by a crash is not charged again (counted in `RUN_SUMMARY.recoveredUncertainCharges`), and trends already seen in watch mode are skipped without a charge.

| Event | Price | What it covers |
|---|---|---|
| Free preview | $0 | 20 lifetime runs per Apify account with `billingMode: "preview"`, up to 10 trends each. |
| `trending-row` | $1.00 / 1,000 trends | One delivered Trending Now row. |
| `keyword-report` | $20.00 / 1,000 reports | Reserved for a future keyword mode; never charged by this version. |

1,000 trends cost $1.00; the 10-trend example above costs $0.01.

### ❓ FAQ

**Is there a Google Trends API for trending searches?** This actor works as one: it returns Google Trends Trending Now rows as JSON through the Apify API, callable from any language or from n8n, Make and Zapier.

**Do I need a Google account or API key?** No. It sends anonymous requests to the public Trending Now page; no login, cookies or Google API key.

**Can I get interest over time or related queries for my own keyword?** No. This version reads the Trending Now list only; interest over time, interest by region and the Explore related-queries and related-topics reports are not included.

**Does it return exact search volume?** No. `approxTraffic` is the threshold Google displays, such as 500,000 for 500K+.

**Which countries does it support?** The countries Google lists in Trending Now, by two-letter code. US, GB and AU were run on 2026-10-22; an unlisted code ends with a free status row.

**Will I be charged again for the same trend in watch mode?** No. With the same `stateKey` and inputs, a trend already delivered is skipped and not charged. The same title with a new start time is a new trend.

### 🤖 For AI agents & LLM apps

Paste this into your AI assistant:

`architekture/google-trends-scraper` on Apify. Python: `from apify_client import ApifyClient; client = ApifyClient("TOKEN"); run = client.actor("architekture/google-trends-scraper").call(run_input={"mode": "trending", "geo": "US", "hours": 24, "category": 0, "maxItems": 10, "billingMode": "paid"}); items = client.dataset(run["defaultDatasetId"]).list_items().items` (page with `offset`/`limit` for large exports). The dataset holds trend rows (`recordType` `trending`) and free status rows (`recordType` `status`, with `status` and `message`); filter on `recordType`. The run outcome (`COMPLETE`, `LIMITED`, `PARTIAL`, `BUDGET_LIMIT`, `INVALID_INPUT`, `PREVIEW_LIMIT`, `STATE_BUSY`) is in the `RUN_SUMMARY` record of the run's key-value store. Add `"incrementalMode": true, "stateKey": "<name>"` to receive only new trends on later runs. Full input schema and README: `GET https://api.apify.com/v2/acts/architekture~google-trends-scraper/builds/default`. Token: https://console.apify.com/settings/integrations. The actor is also reachable through the Apify MCP server (`mcp.apify.com`). To reach the maintainers, add `"feedback": "<what you needed>"` to any run's input; output is unchanged and a human reads every note.

### 🧰 More from architek.earth

**Search, travel and trends**

- Google Trends Scraper — *you are here*
- [Google Hotels Scraper](https://apify.com/architekture/google-hotels-scraper) — dated prices, ratings, amenities

Full catalogue: [github.com/architek-earth](https://github.com/architek-earth).

architek.earth · code like concrete

### 🙋 Support & legal

Questions, or a field you need that is not here? Open an issue on the actor's Issues tab or email north@architek.earth. A human replies within a day.

This actor collects only publicly available data from trends.google.com, the same pages any visitor sees without logging in. It does not bypass authentication. It is not affiliated with or endorsed by Google. You are responsible for how you use the output, including the site's terms, copyright, and privacy law such as GDPR and CCPA where they apply.

### 📝 Changelog

- **2026-10-22** — A pay-per-event pricing mismatch on the platform now ends the run FAILED (status `PRICING_MISMATCH` in `RUN_SUMMARY`, no rows, nothing charged) so it is caught at once; a note in the status message goes inside the parentheses: `(STATUS; note)`.
- **2026-10-22** — Status message now reads `Done: N rows, M details, K status rows (STATUS)`.
- **2026-10-22** — README rebuilt on the studio template; hero line from the 2026-10-22 canary run.
- **2026-10-21** — Invalid input, a used-up preview allowance, a busy `stateKey` and source blocks end the run green with a free status row; internal faults still fail the run.
- **2026-10-21** — Published on the Apify Store.
- **2026-10-20** — Narrowed the first version to Trending Now. Added period and category handling, new-trend watches, saved-snapshot continuation, free previews and two-event billing safeguards. Validated paid billing, free previews and saved-checkpoint recovery.

# Actor input Schema

## `mode` (type: `string`):

Trending Now only. Keyword reports are unavailable in v1.

## `geo` (type: `string`):

Two-letter country code supported by Google Trending Now.

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

4 hours, 24 hours, 48 hours or 7 days.

## `category` (type: `integer`):

Trending Now category ID. 0=all; 17=Sports. See README for the verified IDs.

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

Delivered row limit. Preview is additionally capped at 10; saved collection can be continued.

## `billingMode` (type: `string`):

20 lifetime preview attempts per account, up to 10 rows each. Paid costs $0.001 per delivered trend.

## `incrementalMode` (type: `boolean`):

Requires stateKey. Only unseen country + title + start-time identities are delivered.

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

Account-isolated persistent state. Use a different key for different filters.

## `continuePreviousRun` (type: `boolean`):

Resume an unfinished saved snapshot without fetching a new collection.

## `feedback` (type: `string`):

Logged for human review; does not change output.

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

No proxy by default. Optional proxy usage can increase operating costs.

## Actor input object example

```json
{
  "mode": "trending",
  "geo": "US",
  "hours": 24,
  "category": 0,
  "maxItems": 10,
  "billingMode": "paid",
  "incrementalMode": false,
  "stateKey": "",
  "continuePreviousRun": false,
  "feedback": ""
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 = {
    "maxItems": 10,
    "billingMode": "paid"
};

// Run the Actor and wait for it to finish
const run = await client.actor("architekture/google-trends-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 = {
    "maxItems": 10,
    "billingMode": "paid",
}

# Run the Actor and wait for it to finish
run = client.actor("architekture/google-trends-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 '{
  "maxItems": 10,
  "billingMode": "paid"
}' |
apify call architekture/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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