# Google Trends Data API (`danthedataman/google-trends-data-api`) Actor
Scrape Google Trends interest over time, interest by region, and related/rising queries for any keyword, country and date range. Reliable, proxy-aware, no API key needed.
- **URL**: https://apify.com/danthedataman/google-trends-data-api.md
- **Developed by:** [Eli J](https://apify.com/danthedataman) (community)
- **Categories:** SEO tools, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.25 / 1,000 results
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/platform/actors/running/actors-in-store#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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).
If your project is in a different language, use 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 Data API
Export **Google Trends** data as clean, structured JSON, CSV or Excel — no API key, no browser, no scraping code.
Google does not publish an official Trends API. This Actor talks to the same endpoints the Google Trends website uses and returns the three datasets people actually need:
| Dataset | What you get |
| --- | --- |
| **Interest over time** | The 0–100 popularity score for each date in your range |
| **Interest by region** | The 0–100 score broken down by country, state or sub‑region |
| **Related & rising queries** | The top and fastest‑rising searches associated with your term |
| **Trending now** | What is trending in a country right now — **with estimated search volumes** |
Two modes, one Actor. **Keyword research** analyses terms you supply. **Trending now** needs no keywords at all — pick a country and get the live trending board, each term carrying an estimated search volume (e.g. `500000`), a growth percentage, whether it is still active, and the queries it broke down into.
### Why this Actor
Google aggressively rate-limits its Trends endpoints, which is why most Trends scrapers fail partway through a run and return half a dataset. This Actor is built around that problem:
- **Warmed sessions.** A cold request is rejected before it is even rate-limited. Every session is established the way a browser establishes one.
- **Exponential backoff with jitter.** Genuine rate limits are waited out instead of hammered.
- **Automatic identity rotation.** When an IP gets throttled, the run rotates onto a fresh Apify Proxy session and continues instead of dying.
- **Proactive IP rotation.** Each proxy identity is retired *before* Google throttles it, rather than after. This is the difference between a run that finishes and a run that hangs.
- **Partial failures never kill the run.** If one dataset for one keyword cannot be read, the rest still land, and the problem is reported in the log.
- **Transparent pricing.** You pay per result row. Platform usage is *not* billed on top.
**Measured** (Apify platform, 512 MB, Apify Proxy on, `geo: US`, `today 12-m`, independent mode): 20 keywords × 3 datasets — 20 `explore` calls + 60 widget reads, 80 requests plus session warm-ups — returned **3,006 rows in 50 seconds with 0 errors**. The identical input on the build before proactive rotation stalled on the 15th keyword and had to be aborted after 200 s at 2,112 rows.
### What you get here
Rather than rank the alternatives — they change their pricing and features whenever they like, and any table here would be stale within weeks — here is plainly what this Actor does, so you can check it against whatever else you are considering:
- **Unlimited keywords per run**, each scored on its own scale, or up to 5 on a shared scale for direct comparison.
- **Keyword research and Trending Now in one Actor**, so you are not buying and wiring together two.
- **Every value states its scale.** `valueScale` tells you whether a number is a 0–100 index, a percentage share between compared terms, or a growth percentage. Mixing those up is the most common way to draw a wrong conclusion from Trends data.
- **Sortable ISO-8601 dates**, not locale display strings that drop the year on short ranges.
- **No per-run start fee**, and platform usage is not billed on top of results.
- **Failed requests are never written to your dataset**, so a Google-side error cannot appear on your bill as a result row.
- **Paste a Google Trends URL** instead of filling in fields.
One thing worth knowing before you compare: **Google's Trending Now board is country-level.** Sub-region codes return the parent country's identical board, and metro (DMA) codes return nothing at all — verified by direct testing. This Actor accepts a sub-region code, warns you in the log, and uses the country, rather than implying a precision Google does not provide.
### Input
In keyword mode, only `keywords` is required (or a Trends URL in `startUrls`). In trending mode nothing is required — `geo` defaults to `US`. Everything else has a sensible default.
```json
{
"keywords": ["air fryer", "espresso machine"],
"geo": "US",
"timeRange": "today 12-m",
"dataTypes": ["interest_over_time", "interest_by_region", "related_queries"],
"compareKeywords": false,
"proxyConfiguration": { "useApifyProxy": true }
}
````
| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `keywords` | `keywords` (research) or `trending` (live board). |
| `keywords` | array | — | Search terms, or Google Trends topic IDs such as `/m/0k8z`. |
| `startUrls` | array | — | Paste Trends explore URLs; `q`/`geo`/`date`/`cat` are parsed out. Keywords from several URLs are pooled; geo/date/category come from the **first** URL. |
| `geo` | string | `""` | `US`, `GB`, `DE`, or a sub‑region such as `US-CA`. Empty means Worldwide. |
| `timeRange` | string | `today 12-m` | Preset (`now 1-d`, `today 3-m`, `today 5-y`, `all`, …) or a custom range like `2024-01-01 2024-12-31`. |
| `dataTypes` | array | all three | Which datasets to return. Requesting fewer costs less. |
| `compareKeywords` | boolean | `false` | See below. |
| `searchType` | string | `""` (Web search) | `images`, `news`, `froogle` (Shopping) or `youtube`. Web search is the empty string, not `"web"`. |
| `category` | string | `"0"` | Labelled Google Trends category picker. |
| `language` | string | `en-US` | Language of returned labels. |
| `maxItems` | integer | — | Hard cap on result rows. |
| `maxRetriesPerRequest` | integer | `8` | How hard to retry when Google throttles. |
| `maxRunSeconds` | integer | `3600` | Stop starting new batches after this long, so an outage cannot burn a run. `0` disables. |
| `rotateAfterRequests` | integer | `24` | Retire each proxy identity after N requests. `0` disables. |
| `timezoneOffsetMinutes` | integer | `0` | Offset used to bucket hourly data. |
| `proxyConfiguration` | object | Apify Proxy on | Strongly recommended to leave enabled. |
**Trending-now mode only**
| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `trendingHours` | string | `24` | `4`, `24`, `48` or `168` (7 days). |
| `trendingCategories` | array | all | Multi-select of Google's 19 trending categories. |
| `trendStatus` | string | `all` | `all`, `active` (still rising) or `ended`. |
Trending mode ignores `timeRange`, `dataTypes`, `category`, `searchType`, `compareKeywords`, `language`, `timezoneOffsetMinutes` and `maxRunSeconds`.
#### Independent scores vs. comparison
This matters, and most scrapers get it wrong.
- **`compareKeywords: false` (default)** — each term is fetched on its own and scored **0–100 against itself**. Use this when you want each keyword's own trend shape. You can pass **any number of keywords**. Rows carry `valueScale: "index_0_100"`.
- **`compareKeywords: true`** — up to **5** terms are fetched together on **one shared scale**, so they are directly comparable. This is the Google Trends comparison view.
Read `valueScale` before comparing numbers. In comparison mode `interest_by_region` is a **percentage share between the compared terms** (`valueScale: "comparison_share_percent"`) — Wyoming returns `bitcoin 82%` / `ethereum 18%`, summing to 100 across terms. That is a different quantity from the self-normalised 0–100 index, and mixing them up is the classic way to draw a wrong conclusion from Trends data.
Passing more than 5 terms with comparison on splits them into groups of 5; terms in **different groups are not comparable to each other**, only within their group.
### Output
One flat row per data point — ready for a spreadsheet, a database, or a dashboard.
**Interest over time** — `date` is always a sortable ISO-8601 UTC timestamp; Google's own display label is kept beside it.
```json
{
"keyword": "air fryer",
"dataType": "interest_over_time",
"date": "2025-07-20T00:00:00+00:00",
"dateLabel": "Jul 20, 2025",
"dateRangeLabel": "Jul 20 – 26, 2025",
"timestamp": 1752969600,
"value": 60,
"hasData": true,
"geo": "US",
"timeRange": "today 12-m",
"searchType": "web"
}
```
**Interest by region**
```json
{
"keyword": "air fryer",
"dataType": "interest_by_region",
"geoCode": "US-WY",
"geoName": "Wyoming",
"value": 100,
"formattedValue": "100",
"valueScale": "index_0_100",
"hasData": true
}
```
Rows where `hasData` is `false` are regions Google has no signal for; they carry `value: 0` and are still written (and billed) so the region list stays complete. Filter on `hasData` if you only want regions with real signal.
**Related & rising queries**
```json
{
"keyword": "air fryer",
"dataType": "related_queries",
"rankType": "TOP",
"query": "air fryer chicken",
"value": 100,
"link": "https://trends.google.com/trends/explore?q=air+fryer+chicken&date=today+12-m&geo=US"
}
```
**Trending now** (`mode: "trending"`)
```json
{
"dataType": "trending_now",
"term": "david jonsson",
"geo": "US",
"searchVolume": 500000,
"growthPercent": 1000,
"isActive": true,
"startTimestamp": 1785029400,
"endTimestamp": null,
"categoryIds": [4],
"breakdownQueries": ["david jonsson", "black panther 3", "damson idris"],
"trendsUrl": "https://trends.google.com/trends/explore?q=david+jonsson"
}
```
Filter by the `dataType` field to split the datasets apart, or use the Apify API to export each separately.
### What you can build with it
- **Product research** — find rising products before they peak, and see which states want them.
- **SEO & content planning** — mine `rankType: "RISING"` queries for topics with growing demand.
- **Market entry** — compare brand interest by country before committing spend.
- **Finance & research** — track attention on tickers, technologies or public figures over five years.
- **Dashboards** — schedule a daily run and pipe the dataset into Sheets, BigQuery, or your own store.
### Pricing
Pay per result row, with the Apify platform usage included — you are not billed twice. Requesting only the datasets you need in `dataTypes`, narrowing `timeRange`, or setting `maxItems` all reduce cost directly.
### Notes and limits
- **Keyword-mode** values (`interest_over_time`, `interest_by_region`) are **relative popularity indices**, not absolute search counts — either 0–100 against the term itself, or a percentage share between compared terms. Check `valueScale`.
- **Trending-now** `searchVolume` *is* an absolute figure, but it is Google's own **bucketed lower bound** — `500000` is displayed by Google as "500K+", and `growthPercent` of `1000` means "1,000%+". Treat both as floors, not exact counts; summing them understates the true total.
- Google's *Related topics* widget currently returns an empty list for every query we tested, so this Actor does not offer it rather than shipping a field that is always blank.
- Very long ranges return coarser buckets (5 years → weekly, `all` → monthly). That is Google's own resolution behaviour.
- This Actor collects **public, aggregated, non-personal** statistics only.
### Integrations
Works with everything on the Apify platform: scheduled runs, webhooks, the REST API, the MCP server, Zapier, Make, n8n, Slack, Google Sheets, Airbyte, and LangChain / LlamaIndex.
### Support
Found a bug or need a dataset that isn't here? Open an issue on the Actor's **Issues** tab and I'll take a look.
# Actor input Schema
## `mode` (type: `string`):
Keyword research analyses terms you supply. Trending now ignores keywords and returns what is trending in a country right now, with search volumes.
## `keywords` (type: `array`):
Keywords or Google Trends topic IDs (e.g. /m/0k8z) to analyse. Each term is scraped independently unless Compare keywords is enabled. Ignored in Trending now mode.
## `startUrls` (type: `array`):
Optional. Paste trends.google.com explore URLs; their q / geo / date / cat are parsed into the inputs above. Overrides Search terms when set.
## `geo` (type: `string`):
Two-letter country code (US, GB, DE) or a sub-region such as US-CA. Empty means Worldwide in keyword mode; Trending now mode is country-level and defaults to US.
## `timeRange` (type: `string`):
Period to analyse. You may also type a custom range such as 2024-01-01 2024-12-31.
## `dataTypes` (type: `array`):
Which Google Trends datasets to return. Fewer datasets means fewer results and a lower cost.
## `compareKeywords` (type: `boolean`):
Off (default): every term is scored 0-100 on its own scale, and you may pass unlimited terms. On: up to 5 terms share one scale so their popularity is directly comparable, exactly like the Google Trends comparison view.
## `searchType` (type: `string`):
Which Google property the interest is measured on.
## `category` (type: `string`):
Keyword mode. Narrow the query to one Google Trends category.
## `language` (type: `string`):
Language for the returned labels, e.g. en-US, de, es.
## `timezoneOffsetMinutes` (type: `integer`):
Offset used to bucket hourly data, in minutes. 0 is UTC.
## `trendingHours` (type: `string`):
Trending now mode only. How far back the trending board reaches.
## `trendingCategories` (type: `array`):
Trending now mode. Keep only trends in these categories. Leave empty for all.
## `trendStatus` (type: `string`):
Trending now mode. Keep all trends, only those still rising, or only those that have ended.
## `maxItems` (type: `integer`):
Stop after this many result rows. Leave empty for no limit.
## `maxRunSeconds` (type: `integer`):
Stop starting new batches after this many seconds, so a Google-side outage cannot burn a long run. 0 disables the budget.
## `maxRetriesPerRequest` (type: `integer`):
How hard to retry when Google rate-limits a request. Each retry backs off and rotates the session onto a fresh proxy IP.
## `rotateAfterRequests` (type: `integer`):
Retire each proxy identity after this many requests, before Google throttles it. Lower is safer on large keyword lists; 0 disables proactive rotation.
## `proxyConfiguration` (type: `object`):
Google rate-limits datacenter IPs aggressively. Keeping Apify Proxy enabled is strongly recommended for reliable runs.
## Actor input object example
```json
{
"mode": "keywords",
"keywords": [
"bitcoin"
],
"startUrls": [],
"geo": "US",
"timeRange": "today 12-m",
"dataTypes": [
"interest_over_time",
"interest_by_region",
"related_queries"
],
"compareKeywords": false,
"searchType": "",
"category": "0",
"language": "en-US",
"timezoneOffsetMinutes": 0,
"trendingHours": "24",
"trendStatus": "all",
"maxRunSeconds": 3600,
"maxRetriesPerRequest": 8,
"rotateAfterRequests": 24,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"air fryer",
"espresso machine"
],
"startUrls": []
};
// Run the Actor and wait for it to finish
const run = await client.actor("danthedataman/google-trends-data-api").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": [
"air fryer",
"espresso machine",
],
"startUrls": [],
}
# Run the Actor and wait for it to finish
run = client.actor("danthedataman/google-trends-data-api").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"keywords": [
"air fryer",
"espresso machine"
],
"startUrls": []
}' |
apify call danthedataman/google-trends-data-api --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=danthedataman/google-trends-data-api",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Google Trends Data API",
"description": "Scrape Google Trends interest over time, interest by region, and related/rising queries for any keyword, country and date range. Reliable, proxy-aware, no API key needed.",
"version": "0.7",
"x-build-id": "Jju66n32Ufp5Z1Slk"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/danthedataman~google-trends-data-api/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-danthedataman-google-trends-data-api",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/danthedataman~google-trends-data-api/runs": {
"post": {
"operationId": "runs-sync-danthedataman-google-trends-data-api",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/danthedataman~google-trends-data-api/run-sync": {
"post": {
"operationId": "run-sync-danthedataman-google-trends-data-api",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {
"mode": {
"title": "Mode",
"enum": [
"keywords",
"trending"
],
"type": "string",
"description": "Keyword research analyses terms you supply. Trending now ignores keywords and returns what is trending in a country right now, with search volumes.",
"default": "keywords"
},
"keywords": {
"title": "Search terms",
"type": "array",
"description": "Keywords or Google Trends topic IDs (e.g. /m/0k8z) to analyse. Each term is scraped independently unless Compare keywords is enabled. Ignored in Trending now mode.",
"items": {
"type": "string"
}
},
"startUrls": {
"title": "Google Trends URLs",
"type": "array",
"description": "Optional. Paste trends.google.com explore URLs; their q / geo / date / cat are parsed into the inputs above. Overrides Search terms when set.",
"items": {
"type": "string"
}
},
"geo": {
"title": "Country / region code",
"type": "string",
"description": "Two-letter country code (US, GB, DE) or a sub-region such as US-CA. Empty means Worldwide in keyword mode; Trending now mode is country-level and defaults to US.",
"default": ""
},
"timeRange": {
"title": "Time range",
"type": "string",
"description": "Period to analyse. You may also type a custom range such as 2024-01-01 2024-12-31.",
"default": "today 12-m"
},
"dataTypes": {
"title": "Data to extract",
"type": "array",
"description": "Which Google Trends datasets to return. Fewer datasets means fewer results and a lower cost.",
"items": {
"type": "string",
"enum": [
"interest_over_time",
"interest_by_region",
"related_queries"
],
"enumTitles": [
"Interest over time",
"Interest by region",
"Related & rising queries"
]
},
"default": [
"interest_over_time",
"interest_by_region",
"related_queries"
]
},
"compareKeywords": {
"title": "Compare keywords against each other",
"type": "boolean",
"description": "Off (default): every term is scored 0-100 on its own scale, and you may pass unlimited terms. On: up to 5 terms share one scale so their popularity is directly comparable, exactly like the Google Trends comparison view.",
"default": false
},
"searchType": {
"title": "Search property",
"enum": [
"",
"images",
"news",
"froogle",
"youtube"
],
"type": "string",
"description": "Which Google property the interest is measured on.",
"default": ""
},
"category": {
"title": "Category",
"enum": [
"0",
"3",
"5",
"7",
"8",
"11",
"12",
"13",
"14",
"16",
"18",
"19",
"20",
"22",
"29",
"44",
"45",
"47",
"65",
"66",
"67",
"71",
"174",
"299",
"533",
"958"
],
"type": "string",
"description": "Keyword mode. Narrow the query to one Google Trends category.",
"default": "0"
},
"language": {
"title": "Language",
"type": "string",
"description": "Language for the returned labels, e.g. en-US, de, es.",
"default": "en-US"
},
"timezoneOffsetMinutes": {
"title": "Timezone offset (minutes)",
"type": "integer",
"description": "Offset used to bucket hourly data, in minutes. 0 is UTC.",
"default": 0
},
"trendingHours": {
"title": "Trending window",
"enum": [
"4",
"24",
"48",
"168"
],
"type": "string",
"description": "Trending now mode only. How far back the trending board reaches.",
"default": "24"
},
"trendingCategories": {
"title": "Trending categories",
"type": "array",
"description": "Trending now mode. Keep only trends in these categories. Leave empty for all.",
"items": {
"type": "string",
"enum": [
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
"11",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20"
],
"enumTitles": [
"Autos and Vehicles",
"Beauty and Fashion",
"Business and Finance",
"Entertainment",
"Food and Drink",
"Games",
"Health",
"Hobbies and Leisure",
"Jobs and Education",
"Law and Government",
"Other",
"Pets and Animals",
"Politics",
"Science",
"Shopping",
"Sports",
"Technology",
"Travel and Transportation",
"Climate"
]
}
},
"trendStatus": {
"title": "Trend status",
"enum": [
"all",
"active",
"ended"
],
"type": "string",
"description": "Trending now mode. Keep all trends, only those still rising, or only those that have ended.",
"default": "all"
},
"maxItems": {
"title": "Maximum results",
"minimum": 0,
"type": "integer",
"description": "Stop after this many result rows. Leave empty for no limit."
},
"maxRunSeconds": {
"title": "Run time budget (seconds)",
"minimum": 0,
"type": "integer",
"description": "Stop starting new batches after this many seconds, so a Google-side outage cannot burn a long run. 0 disables the budget.",
"default": 3600
},
"maxRetriesPerRequest": {
"title": "Max retries per request",
"minimum": 1,
"maximum": 20,
"type": "integer",
"description": "How hard to retry when Google rate-limits a request. Each retry backs off and rotates the session onto a fresh proxy IP.",
"default": 8
},
"rotateAfterRequests": {
"title": "Rotate proxy IP every N requests",
"minimum": 0,
"maximum": 200,
"type": "integer",
"description": "Retire each proxy identity after this many requests, before Google throttles it. Lower is safer on large keyword lists; 0 disables proactive rotation.",
"default": 24
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Google rate-limits datacenter IPs aggressively. Keeping Apify Proxy enabled is strongly recommended for reliable runs.",
"default": {
"useApifyProxy": true
}
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```