# Multi-Keyword Google Trends Scraper — Trending Keywords Compare (`k1ra/google-trends-scraper`) Actor

Fast HTTP Google Trends API - no browser, no timeouts, results in seconds. Compare up to 5 keywords side by side: interest over time, by region, related queries, and trending now searches. Google search trends data via pure API. Pay per keyword, $0 on empty runs.

- **URL**: https://apify.com/k1ra/google-trends-scraper.md
- **Developed by:** [Kevin Savani](https://apify.com/k1ra) (community)
- **Categories:** SEO tools, Developer tools, Lead generation
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Multi-Keyword Google Trends Scraper — Trending Keywords Compare

Compare up to **5 keywords side by side** on Google Trends — the same normalized comparison the Google Trends website itself shows, not five separate lookups bolted together. Get **interest over time**, **interest by region**, **related queries**, **related topics**, and **trending now** searches, all in one fast run. No browser, no 20-minute timeouts — results in seconds.

**Pay per keyword — and pay nothing when a run returns no results.**

---

### Why Choose This Google Trends Scraper

- ⚡ **Fast** — a 5-keyword comparison completes in seconds, not the multi-minute waits reported for browser-based Trends scrapers.
- 🔀 **Real multi-keyword comparison** — pass up to 5 keywords and get Google's own normalized, side-by-side comparison values, not five independent single-keyword scores stitched together.
- 📊 **Complete output** — interest over time, interest by region, related queries, related topics*, and trending now, with formatted display values, a "leading keyword per region" flag, and direct Google Trends links included at no extra cost.
- 💸 **Honest pricing** — pay per keyword delivered, **$0 on a run that returns nothing**, plus an optional hard cost cap.
- 🧹 **Clean output** — one structured record per keyword, ready for CSV/Sheets/BI tools without post-processing.
- 🌍 **Any geo, any category** — the full Google Trends country list and category taxonomy, worldwide or region-specific.

*Related topics is only available when comparing a single keyword — Google's own comparison view drops it once you compare 2+ keywords, and even then it can occasionally return no data for a given keyword. Related queries, interest over time, and interest by region are unaffected and always populate when data exists.

---

### How It Compares

| Feature | **This Scraper** | Typical Google Trends scrapers |
|---|:---:|:---:|
| Speed | ✅ seconds | ⚠️ reported multi-minute runs / timeouts |
| Multi-keyword comparison | ✅ up to 5, real comparison | ❌ single-keyword only, or broken multi-param |
| Interest by region + leading keyword | ✅ | ⚠️ varies |
| Related queries | ✅ | ⚠️ varies |
| Trending now | ✅ | ⚠️ often a separate, limited actor |
| Pricing | ✅ pay per keyword, **$0 on empty** | ❌ per-run / per-minute charges even on empty results |

---

### Use Cases

#### Multi-Keyword Google Trends Comparison
Compare up to 5 keywords, brands, or competitors on one normalized 0–100 scale — the same comparison Google Trends' own Explore page shows, not independent single-keyword numbers.

#### Google Trends API
Drop this into a pipeline, notebook, or BI dashboard as a **Google Trends API** — one structured JSON record per keyword, no scraping or parsing logic on your end.

#### Trending Keywords Scraper
Pull today's **trending searches** for any country — headline, estimated traffic, publish time, and linked news articles — independent of any keyword you're tracking.

#### Google Trends Data for SEO & Market Research
Feed **interest over time** and **interest by region** into keyword-research, content-calendar, or regional-demand-forecasting workflows.

#### Compare Google Trends Keywords for Product & Brand Tracking
Track your brand against up to 4 competitors' search interest over time, and see which regions and related queries are driving the gap — every region record flags which keyword is actually leading there.

---

### Who Uses This

| Use Case | Who It's For |
|---|---|
| Competitive keyword/brand tracking | Marketers, SEO teams, brand managers |
| Content & keyword research | SEO analysts, content teams |
| Regional demand analysis | Market researchers, retail/e-commerce teams |
| Trending-topic monitoring | Social/news teams, trend-driven content creators |
| Dashboards & pipelines | Data teams building internal Trends dashboards |

---

### Input

| Field | Description |
|---|---|
| `keywords` | 1–5 search terms. 2+ triggers Google's normalized comparison mode. |
| `geo` | Country to get results from. Empty = worldwide. |
| `category` | Restrict to a Google Trends category. Empty = all categories. |
| `timeRange` | Preset time range (past hour up to 2004–present). |
| `customTimeRange` | Optional `YYYY-MM-DD YYYY-MM-DD` override. |
| `interestOverTime` | Include the interest-over-time series (default on). |
| `interestByRegion` | Include interest by region (default on). |
| `relatedQueries` | Include related queries (default on). |
| `relatedTopics` | Include related topics — single-keyword only (default on). |
| `trendingNow` | Include today's trending searches for `geo` (default off). Works with or without `keywords`. |
| `maxRelatedItems` | Cap items per related-queries/topics list, per keyword (default 25). |
| `maxCostUsd` | Hard cap on total run cost. 0 = no cap. |

#### Example input

```json
{
  "keywords": ["bitcoin", "ethereum", "solana"],
  "geo": "US",
  "timeRange": "today 12-m",
  "interestOverTime": true,
  "interestByRegion": true,
  "relatedQueries": true,
  "trendingNow": false
}
````

***

### Output

One record per keyword, with every enabled view nested inside it — plus a separate record for trending-now when enabled. A keyword that returns no data at all is omitted (and never billed).

```json
{
  "keyword": "bitcoin",
  "geo": "US",
  "category": null,
  "timeRange": "today 12-m",
  "scrapedAt": "2026-07-06T18:05:16Z",
  "interestOverTime": [
    { "date": "Jul 6, 2025", "value": 38, "formattedValue": "38", "hasData": true, "isPartial": false }
  ],
  "interestByRegion": [
    { "geoCode": "US-SD", "geoName": "South Dakota", "value": 82, "formattedValue": "82%", "isLeading": true }
  ],
  "relatedQueries": {
    "top": [
      { "query": "bitcoin price", "value": 100, "formattedValue": "100", "breakout": false, "link": "https://trends.google.com/trends/explore?q=bitcoin+price&date=today+12-m&geo=US" }
    ],
    "rising": [
      { "query": "bitcoin etf", "value": 32050, "formattedValue": "Breakout", "breakout": true, "link": "..." }
    ]
  }
}
```

Trending-now record:

```json
{
  "geo": "US",
  "scrapedAt": "2026-07-06T18:05:39Z",
  "trends": [
    {
      "title": "taylor swift wedding",
      "traffic": "5000+",
      "pubDate": "Mon, 6 Jul 2026 10:50:00 -0700",
      "articles": [{ "title": "...", "url": "...", "source": "..." }]
    }
  ]
}
```

`isLeading` marks the region where a keyword's value is the highest among all compared keywords — a direct answer to "who's winning where" in a multi-keyword comparison. `breakout` marks a related query/topic Google reports as a >5000% spike (`formattedValue: "Breakout"`) rather than a percentage.

***

### Pricing

**$0.02 per keyword delivered, $0.01 per trending-now snapshot.** No flat monthly fee, and **`$0` on a run that returns nothing** — you're never charged for an empty or failed lookup.

***

### FAQ

**Does multi-keyword mode really compare keywords, or run them separately?**
It's a real comparison — the same normalized, side-by-side values Google Trends' own Explore page shows when you compare keywords, not independent single-keyword scores.

**Is related topics always included?**
It's included by default and populates for a single keyword when Google has topic data for it; it's not available at all once you're comparing 2+ keywords (that's Google's own comparison view, not a limitation of this actor).

**Will I be charged if a run returns nothing?**
No — `$0` on empty, always.

**Can I cap my spend?**
Yes — set `maxCostUsd` and the run stops before exceeding it.

**Does it work worldwide?**
Yes — leave `geo` empty for worldwide results, or pick any country.

**Can I get trending searches without tracking any keywords?**
Yes — enable `trendingNow` and leave `keywords` empty.

***

### ⭐ Bookmark this Actor & Leave a Review

If this Google Trends scraper saves you time:

- **⭐ Star it** at the top of the page to bookmark it and help other Apify users find it.
- **📝 Leave a review** — even one sentence on your use case helps prioritize the next feature (extra time-range granularity, additional geo breakdowns, and more).

***

### Related Apify Actors

- [Google Trends Scrapers](https://apify.com/store?search=google%20trends) — other Trends actors
- [SEO Tools](https://apify.com/store?category=SEO_TOOLS) — the full Apify SEO catalog
- [Keyword Research Tools](https://apify.com/store?search=keyword%20research) — related keyword-research actors

***

### Support & Feedback

Found a bug or want a new field, geo breakdown, or time-range option?

- **Open an issue** on the actor's Issues tab in the Apify Console.
- **Feature requests** are welcome.

# Actor input Schema

## `keywords` (type: `array`):

1-5 search terms. With 2+ keywords, Google returns a normalized side-by-side comparison (0-100 relative scale across all keywords together) instead of each keyword's own independent score - that's expected Google Trends behavior, not a bug.

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

Country to get results from. Defaults to Worldwide.

## `category` (type: `string`):

Restrict results to a Google Trends category. Defaults to All categories.

## `timeRange` (type: `string`):

Predefined time range. Ignored if Custom time range is set.

## `customTimeRange` (type: `string`):

Optional 'YYYY-MM-DD YYYY-MM-DD' range; overrides Time range when set.

## `interestOverTime` (type: `boolean`):

Search interest timeseries per keyword.

## `interestByRegion` (type: `boolean`):

Search interest broken down by subregion, per keyword.

## `relatedQueries` (type: `boolean`):

Top and rising related search queries, per keyword.

## `relatedTopics` (type: `boolean`):

Top and rising related topics, per keyword. Only available when a single keyword is given - Google drops this dataset entirely once you compare 2+ keywords.

## `trendingNow` (type: `boolean`):

Today's trending searches for Geo area. Independent of Keywords.

## `maxRelatedItems` (type: `integer`):

Caps rows per related-queries/related-topics list, per keyword. Google returns at most 25.

## `maxCostUsd` (type: `integer`):

Hard cap on total run cost; the run stops before exceeding it. 0 = no cap.

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

Not required - this actor supplies its own residential proxy by default. Leave as-is unless you need to override it.

## Actor input object example

```json
{
  "keywords": [
    "bitcoin"
  ],
  "geo": "",
  "category": "",
  "timeRange": "today 12-m",
  "interestOverTime": true,
  "interestByRegion": true,
  "relatedQueries": true,
  "relatedTopics": true,
  "trendingNow": false,
  "maxRelatedItems": 25,
  "maxCostUsd": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "keywords": [
        "bitcoin"
    ],
    "customTimeRange": "",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k1ra/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 = {
    "keywords": ["bitcoin"],
    "customTimeRange": "",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("k1ra/google-trends-scraper").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": [
    "bitcoin"
  ],
  "customTimeRange": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call k1ra/google-trends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=k1ra/google-trends-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-Keyword Google Trends Scraper — Trending Keywords Compare",
        "description": "Fast HTTP Google Trends API - no browser, no timeouts, results in seconds. Compare up to 5 keywords side by side: interest over time, by region, related queries, and trending now searches. Google search trends data via pure API. Pay per keyword, $0 on empty runs.",
        "version": "0.1",
        "x-build-id": "2P77aFRBXCoxchHSg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/k1ra~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-k1ra-google-trends-scraper",
                "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/k1ra~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-k1ra-google-trends-scraper",
                "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/k1ra~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-k1ra-google-trends-scraper",
                "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": {
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 5,
                        "type": "array",
                        "description": "1-5 search terms. With 2+ keywords, Google returns a normalized side-by-side comparison (0-100 relative scale across all keywords together) instead of each keyword's own independent score - that's expected Google Trends behavior, not a bug.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geo": {
                        "title": "Geo area",
                        "enum": [
                            "",
                            "AF",
                            "AL",
                            "DZ",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AQ",
                            "AG",
                            "AR",
                            "AM",
                            "AW",
                            "AU",
                            "AT",
                            "AZ",
                            "BS",
                            "BH",
                            "BD",
                            "BB",
                            "BY",
                            "BE",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BQ",
                            "BA",
                            "BW",
                            "BV",
                            "BR",
                            "IO",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "CV",
                            "KH",
                            "CM",
                            "CA",
                            "KY",
                            "CF",
                            "TD",
                            "CL",
                            "CN",
                            "CX",
                            "Keeling Islands ",
                            "CO",
                            "KM",
                            "CG",
                            "CD",
                            "CK",
                            "CR",
                            "CI",
                            "HR",
                            "CU",
                            "CW",
                            "CY",
                            "CZ",
                            "DK",
                            "DJ",
                            "DM",
                            "DO",
                            "EC",
                            "EG",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "Malvinas ",
                            "FO",
                            "FJ",
                            "FI",
                            "FR",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "DE",
                            "GH",
                            "GI",
                            "GR",
                            "GL",
                            "GD",
                            "GP",
                            "GU",
                            "GT",
                            "GG",
                            "GN",
                            "GW",
                            "GY",
                            "HT",
                            "HM",
                            "Vatican City State ",
                            "HN",
                            "HK",
                            "HU",
                            "IS",
                            "IN",
                            "ID",
                            "IR",
                            "IQ",
                            "IE",
                            "IM",
                            "IL",
                            "IT",
                            "JM",
                            "JP",
                            "JE",
                            "JO",
                            "KZ",
                            "KE",
                            "KI",
                            "the Democratic People's Republic of ",
                            "the Republic of ",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MK",
                            "MG",
                            "MW",
                            "MY",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "MX",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MA",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "NL",
                            "NC",
                            "NZ",
                            "NI",
                            "NE",
                            "NG",
                            "NU",
                            "NF",
                            "MP",
                            "NO",
                            "OM",
                            "PK",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PE",
                            "PH",
                            "PN",
                            "PL",
                            "PT",
                            "PR",
                            "QA",
                            "RE",
                            "RO",
                            "RU",
                            "RW",
                            "BL",
                            "SH",
                            "KN",
                            "LC",
                            "French part ",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SA",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SG",
                            "Dutch part ",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "ZA",
                            "GS",
                            "SS",
                            "ES",
                            "LK",
                            "SD",
                            "SR",
                            "SJ",
                            "SZ",
                            "SE",
                            "CH",
                            "SY",
                            "TW",
                            "TJ",
                            "TZ",
                            "TH",
                            "TL",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TN",
                            "TR",
                            "TM",
                            "TC",
                            "TV",
                            "UG",
                            "UA",
                            "AE",
                            "GB",
                            "US",
                            "UM",
                            "UY",
                            "UZ",
                            "VU",
                            "VE",
                            "VN",
                            "VG",
                            "VI",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "Country to get results from. Defaults to Worldwide.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "3",
                            "47",
                            "44",
                            "22",
                            "12",
                            "5",
                            "7",
                            "71",
                            "8",
                            "45",
                            "65",
                            "11",
                            "13",
                            "958",
                            "19",
                            "16",
                            "299",
                            "14",
                            "66",
                            "29",
                            "533",
                            "174",
                            "18",
                            "20",
                            "67"
                        ],
                        "type": "string",
                        "description": "Restrict results to a Google Trends category. Defaults to All categories.",
                        "default": ""
                    },
                    "timeRange": {
                        "title": "Time range",
                        "enum": [
                            "now 1-H",
                            "now 4-H",
                            "now 1-d",
                            "now 7-d",
                            "today 1-m",
                            "today 3-m",
                            "today 12-m",
                            "today 5-y",
                            "all"
                        ],
                        "type": "string",
                        "description": "Predefined time range. Ignored if Custom time range is set.",
                        "default": "today 12-m"
                    },
                    "customTimeRange": {
                        "title": "Custom time range",
                        "type": "string",
                        "description": "Optional 'YYYY-MM-DD YYYY-MM-DD' range; overrides Time range when set."
                    },
                    "interestOverTime": {
                        "title": "Include interest over time",
                        "type": "boolean",
                        "description": "Search interest timeseries per keyword.",
                        "default": true
                    },
                    "interestByRegion": {
                        "title": "Include interest by region",
                        "type": "boolean",
                        "description": "Search interest broken down by subregion, per keyword.",
                        "default": true
                    },
                    "relatedQueries": {
                        "title": "Include related queries",
                        "type": "boolean",
                        "description": "Top and rising related search queries, per keyword.",
                        "default": true
                    },
                    "relatedTopics": {
                        "title": "Include related topics",
                        "type": "boolean",
                        "description": "Top and rising related topics, per keyword. Only available when a single keyword is given - Google drops this dataset entirely once you compare 2+ keywords.",
                        "default": true
                    },
                    "trendingNow": {
                        "title": "Include trending now",
                        "type": "boolean",
                        "description": "Today's trending searches for Geo area. Independent of Keywords.",
                        "default": false
                    },
                    "maxRelatedItems": {
                        "title": "Max related items per keyword",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Caps rows per related-queries/related-topics list, per keyword. Google returns at most 25.",
                        "default": 25
                    },
                    "maxCostUsd": {
                        "title": "Max cost (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total run cost; the run stops before exceeding it. 0 = no cap.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Not required - this actor supplies its own residential proxy by default. Leave as-is unless you need to override it.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
