# Google Trends Scraper (`solidcode/google-trends-scraper`) Actor

Extract Google Trends data — interest over time, regional breakdowns, related queries and topics — by search term or URL.

- **URL**: https://apify.com/solidcode/google-trends-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

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

## 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

## Google Trends Scraper

Pull the full Google Trends dataset for any keyword, country, and time range — interest over time, regional breakdowns (country / state / metro / city), and the top and rising related queries and topics. Built for marketers, analysts, investors, and product teams who need trend data at scale without clicking through Google Trends one search at a time.

### Why This Scraper?

- **Every Google Trends panel in one record** — timeline, regional breakdown, related queries (top + rising), and related topics (top + rising), all for a single search term in a single dataset item
- **Compare up to 5 terms side-by-side** — put `"coffee, tea, matcha"` in one entry and get a multi-series timeline with each term's relative interest
- **Worldwide or country-level detail** — pick "Worldwide" to see which countries are most interested, or pick a country to drill into states, metros, and cities
- **Paste Google Trends URLs directly** — already applied filters in the browser? Copy the URL and we preserve every filter (geo, time range, category) automatically
- **Human-readable inputs** — pick "United States" and "Arts & Entertainment" from dropdowns instead of decoding ISO codes and numeric category IDs
- **9 time-range presets plus custom date ranges** — from "Past hour" to "2004 – present", or supply any exact `YYYY-MM-DD YYYY-MM-DD` window
- **All 25 Google Trends categories** — filter to Finance, Health, Shopping, Travel, and 21 more to cut noise from unrelated searches
- **Choose where Trends is viewed from** — Google Trends results vary by viewer location. Pick the country matching your audience for geographically-accurate data
- **$2 per 1,000 results** — one of the lowest prices on Apify for Google Trends data

### Use Cases

**SEO & Content Strategy**
- Discover rising search queries around any topic to write content people are actively looking for
- Find long-tail keyword opportunities from the "Top" related queries panel
- Validate whether a keyword's interest is seasonal, trending up, or declining before investing in content

**Market Research & Trend Forecasting**
- Track interest in product categories, brands, or cultural topics across any time window
- Compare competing brands, products, or terms head-to-head on a normalized interest scale
- Identify which regions, states, or cities are the hottest market for a given product or service

**Finance & Investment Signal**
- Monitor retail interest in tickers, cryptocurrencies, and asset classes as a sentiment leading indicator
- Pull historical trend data back to 2004 for backtesting and time-series analysis
- Watch "Rising" related queries to catch narrative shifts early

**Advertising & Campaign Planning**
- Match ad creative and launch timing to when interest is peaking in each region
- Size the opportunity in specific DMAs (designated market areas) before allocating budget
- Compare branded vs unbranded search interest over time

**Product & Brand Monitoring**
- Track share of interest between your brand and competitors week over week
- Catch emerging competitor names in the "Rising" related queries panel
- Feed trend data into dashboards alongside sales, reviews, and social mentions

### Getting Started

#### Simple Search

Enter a single term — everything else defaults to sensible values (Worldwide, past 12 months, all categories):

```json
{
    "searchTerms": ["bitcoin"]
}
````

#### Multiple Independent Searches

Each entry runs as its own search. Great for building a keyword universe:

```json
{
    "searchTerms": ["bitcoin", "ethereum", "solana", "dogecoin"],
    "geo": "US",
    "timeRange": "today 5-y"
}
```

#### Side-by-Side Comparison

Separate terms with commas inside a single entry to get one multi-series timeline on the same chart. Up to 5 terms per comparison:

```json
{
    "searchTerms": ["coffee, tea, matcha"],
    "geo": "JP",
    "timeRange": "today 12-m",
    "category": "71"
}
```

#### Custom Date Range

Pull an exact time window — useful for pre/post analysis (product launch, news event, seasonal campaign):

```json
{
    "searchTerms": ["black friday deals"],
    "customTimeRange": "2024-11-01 2024-12-15",
    "geo": "US"
}
```

#### Paste Google Trends URLs

Already dialed in your filters in the browser? Paste the URL — every filter is preserved:

```json
{
    "startUrls": [
        "https://trends.google.com/trends/explore?date=today%2012-m&geo=US-CA&q=electric%20vehicles&cat=47"
    ]
}
```

#### Worldwide Country Breakdown

Leave `geo` empty to see interest broken down by country worldwide:

```json
{
    "searchTerms": ["world cup"],
    "timeRange": "today 3-m"
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["bitcoin"]` | Topics to analyze. Each entry is an independent search. Separate with commas in a single entry to compare up to 5 terms side-by-side |
| `startUrls` | string\[] | `[]` | Paste Google Trends URLs to reuse filters you've already applied in the browser. Overrides Time range, Geo, and Category when provided |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `timeRange` | string | `"today 12-m"` (Past 12 months) | Time window preset — `"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"` (2004–present) |
| `customTimeRange` | string | `null` | Exact date range `YYYY-MM-DD YYYY-MM-DD`. Overrides the Time range preset |
| `geo` | string | `""` (Worldwide) | Country to analyze interest in. Worldwide shows country-level breakdown; picking a country shows state / metro / city breakdown |
| `category` | string | `"0"` (All categories) | One of 26 Google Trends category filters (All, Arts & Entertainment, Business, Finance, Health, Shopping, Travel, …) |

#### Proxy

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `viewedFrom` | string | `"us"` | Country to fetch Google Trends from. Google Trends results vary by viewer location — pick the country matching your end users for accurate data |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `0` (unlimited) | Hard cap on dataset items returned |

### Output

One record per search term, with every Google Trends panel filled in:

```json
{
    "inputUrlOrTerm": "bitcoin",
    "searchTerm": "bitcoin",
    "interestOverTime_timelineData": [
        {
            "time": 1712188800,
            "formattedTime": "Apr 4, 2024",
            "formattedAxisTime": "Apr 4",
            "value": [72],
            "hasData": [true],
            "formattedValue": ["72"]
        }
    ],
    "interestOverTime_averages": [],
    "interestBySubregion": [
        {
            "geoCode": "US-WY",
            "geoName": "Wyoming",
            "value": [100],
            "formattedValue": ["100"],
            "maxValueIndex": 0,
            "hasData": [true]
        },
        {
            "geoCode": "US-NV",
            "geoName": "Nevada",
            "value": [99],
            "formattedValue": ["99"],
            "maxValueIndex": 0,
            "hasData": [true]
        }
    ],
    "interestByCity": [],
    "interestByMetro": [],
    "interestBy": [],
    "relatedQueries_top": [
        {
            "query": "bitcoin price",
            "value": 100,
            "formattedValue": "100",
            "hasData": true,
            "link": "/trends/explore?q=bitcoin+price&date=today+12-m&geo=US"
        },
        {
            "query": "bitcoin stock",
            "value": 17,
            "formattedValue": "17",
            "hasData": true,
            "link": "/trends/explore?q=bitcoin+stock&date=today+12-m&geo=US"
        }
    ],
    "relatedQueries_rising": [
        {
            "query": "bitcoin etf",
            "value": 250,
            "formattedValue": "+250%",
            "hasData": true,
            "link": "/trends/explore?q=bitcoin+etf&date=today+12-m&geo=US"
        }
    ],
    "relatedTopics_top": [
        {
            "topic": { "mid": "/m/05p0rrx", "title": "Bitcoin", "type": "Cryptocurrency" },
            "value": 100,
            "formattedValue": "100",
            "hasData": true,
            "link": "/trends/explore?q=%2Fm%2F05p0rrx&date=today+12-m&geo=US"
        }
    ],
    "relatedTopics_rising": []
}
```

#### All Available Fields

| Field | Type | Description |
|-------|------|-------------|
| `inputUrlOrTerm` | string | The original term or URL you provided that produced this record |
| `searchTerm` | string | Normalized search term (decoded from a URL when `startUrls` was used) |
| `interestOverTime_timelineData` | object\[] | Timeline points with `time`, `formattedTime`, `formattedAxisTime`, `value`, `formattedValue`, `hasData`, and `isPartial` when the last point is still forming |
| `interestOverTime_averages` | number\[] | Average interest per compared term (populated only when comparing multiple terms) |
| `interestBy` | object\[] | Country-level interest (when Geo is set to Worldwide) |
| `interestBySubregion` | object\[] | State / province-level interest (when Geo is a country that exposes subregions) |
| `interestByMetro` | object\[] | Metro / DMA-level interest (when Geo is a US state or similar) |
| `interestByCity` | object\[] | City-level interest (when the target geo exposes cities) |
| `relatedQueries_top` | object\[] | Most-searched related queries — `query`, `value` (0–100 normalized), `formattedValue`, `hasData`, `link` |
| `relatedQueries_rising` | object\[] | Fastest-growing related queries — same shape, with growth % in `formattedValue` |
| `relatedTopics_top` | object\[] | Most-searched related topics — `topic.mid`, `topic.title`, `topic.type`, `value`, `formattedValue`, `hasData`, `link` |
| `relatedTopics_rising` | object\[] | Fastest-growing related topics — same shape |

Each geo / region / city row carries a `value` array that is N-long for an N-term comparison, so a 2-term compare puts both terms' values on every row.

### Tips for Best Results

#### Geo Granularity

- **Worldwide** — returns country-level interest (`interestBy` field filled in)
- **A single country** — returns state / province (`interestBySubregion`) and, for countries that support it, city (`interestByCity`) and metro (`interestByMetro`)
- **A URL with `geo=US-CA`** (a state) — drills down to city and metro level

#### Comparing Terms

- Put up to **5 terms in one entry separated by commas** to get one multi-series chart with normalized values
- Put terms in **separate entries** to run each as its own independent search — best when you want each term to anchor its own 0–100 scale
- The `interestOverTime_averages` field is populated only in multi-term comparisons — it gives you each term's average interest on the shared scale

#### Time Ranges

- **"Past hour" and "Past 4 hours"** use Google Trends' realtime data (different backend) — great for news monitoring
- **"2004 – present"** is the longest window — ideal for long-horizon backtests
- **Custom date ranges** must be `YYYY-MM-DD YYYY-MM-DD` — the second date must be today or earlier

#### View Location

- Google Trends results vary by where the viewer is located. If your audience is in Germany, set **View Trends from** = Germany to get data that reflects what a German user would see

#### Bulk Runs

- Build a keyword list in Google Sheets and feed it into the actor via the Apify Sheets integration or the API — the actor will loop through each term automatically

### Pricing

**$2 per 1,000 results** — one of the lowest prices on Apify for Google Trends data.

| Results | Cost |
|---------|------|
| 100 | $0.20 |
| 1,000 | $2.00 |
| 10,000 | $20.00 |
| 100,000 | $200.00 |

Platform fees (compute, proxy, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export or keyword-list import
- **Slack** / **Email** — Notifications on run completion
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, SEO, content strategy, and business intelligence. Users are responsible for complying with applicable laws and Google's Terms of Service. The output contains aggregated, anonymized interest data — no personal information is collected.

# Actor input Schema

## `searchTerms` (type: `array`):

Topics you want to analyze. Add multiple entries to scrape each independently. To compare up to 5 terms side-by-side in a single Google Trends view, put them in one entry separated by commas (e.g. "coffee, tea").

## `startUrls` (type: `array`):

Paste Google Trends URLs (e.g. from your browser address bar after applying filters). When provided, the filters in each URL override the Time range, Geo, and Category options below.

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

How far back to pull interest data.

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

Exact date range in the format YYYY-MM-DD YYYY-MM-DD (e.g. "2024-01-01 2024-06-30"). When set, this overrides the Time range preset above.

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

Country to analyze interest in. Choose "Worldwide" to see interest broken down by country; choose a country to see state/city breakdown (only larger countries expose subregion data).

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

Google Trends category to filter by.

## `viewedFrom` (type: `string`):

Country to fetch Google Trends from. Pick the country your end users are in for geographically-accurate trends. Defaults to the United States.

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

Hard cap on the number of dataset items returned. Set to 0 for no limit.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin"
  ],
  "startUrls": [],
  "timeRange": "today 12-m",
  "geo": "",
  "category": "0",
  "viewedFrom": "us",
  "maxItems": 0
}
```

# Actor output Schema

## `overview` (type: `string`):

Search term, geo, and timeline summary.

## `timeline` (type: `string`):

Timeline points flattened from interestOverTime\_timelineData.

## `relatedQueries` (type: `string`):

Top and rising related queries for each term.

# 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 = {
    "searchTerms": [
        "bitcoin"
    ],
    "startUrls": [],
    "timeRange": "today 12-m",
    "geo": "",
    "category": "0",
    "viewedFrom": "us",
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchTerms": ["bitcoin"],
    "startUrls": [],
    "timeRange": "today 12-m",
    "geo": "",
    "category": "0",
    "viewedFrom": "us",
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchTerms": [
    "bitcoin"
  ],
  "startUrls": [],
  "timeRange": "today 12-m",
  "geo": "",
  "category": "0",
  "viewedFrom": "us",
  "maxItems": 0
}' |
apify call solidcode/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper",
        "description": "Extract Google Trends data — interest over time, regional breakdowns, related queries and topics — by search term or URL.",
        "version": "1.0",
        "x-build-id": "ELqiD4nmQBlqhvGaz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Topics you want to analyze. Add multiple entries to scrape each independently. To compare up to 5 terms side-by-side in a single Google Trends view, put them in one entry separated by commas (e.g. \"coffee, tea\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Trends URLs",
                        "type": "array",
                        "description": "Paste Google Trends URLs (e.g. from your browser address bar after applying filters). When provided, the filters in each URL override the Time range, Geo, and Category options below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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": "How far back to pull interest data.",
                        "default": "today 12-m"
                    },
                    "customTimeRange": {
                        "title": "Custom date range",
                        "type": "string",
                        "description": "Exact date range in the format YYYY-MM-DD YYYY-MM-DD (e.g. \"2024-01-01 2024-06-30\"). When set, this overrides the Time range preset above."
                    },
                    "geo": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BR",
                            "MX",
                            "IN",
                            "JP",
                            "KR",
                            "CN",
                            "RU",
                            "TR",
                            "AR",
                            "PL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "IE",
                            "BE",
                            "CH",
                            "AT",
                            "PT",
                            "GR",
                            "CZ",
                            "RO",
                            "HU",
                            "IL",
                            "AE",
                            "SA",
                            "ZA",
                            "NG",
                            "EG",
                            "ID",
                            "PH",
                            "TH",
                            "VN",
                            "MY",
                            "SG",
                            "HK",
                            "TW",
                            "NZ",
                            "CL",
                            "CO",
                            "PE",
                            "VE",
                            "UA",
                            "PK",
                            "BD",
                            "LK",
                            "KE",
                            "MA",
                            "DZ",
                            "TN",
                            "AF",
                            "AL",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AQ",
                            "AG",
                            "AM",
                            "AW",
                            "AZ",
                            "BS",
                            "BH",
                            "BB",
                            "BY",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BA",
                            "BW",
                            "BV",
                            "IO",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "CV",
                            "KH",
                            "CM",
                            "KY",
                            "CF",
                            "TD",
                            "CX",
                            "CC",
                            "KM",
                            "CG",
                            "CD",
                            "CK",
                            "CR",
                            "CI",
                            "HR",
                            "CU",
                            "CY",
                            "DJ",
                            "DM",
                            "DO",
                            "EC",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "FK",
                            "FO",
                            "FJ",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "GH",
                            "GI",
                            "GL",
                            "GD",
                            "GP",
                            "GU",
                            "GT",
                            "GN",
                            "GW",
                            "GY",
                            "HT",
                            "HM",
                            "VA",
                            "HN",
                            "IS",
                            "IR",
                            "IQ",
                            "JM",
                            "JO",
                            "KZ",
                            "KI",
                            "KP",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MK",
                            "MG",
                            "MW",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "NC",
                            "NI",
                            "NE",
                            "NU",
                            "NF",
                            "MP",
                            "OM",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PN",
                            "PR",
                            "QA",
                            "RE",
                            "RW",
                            "SH",
                            "KN",
                            "LC",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "GS",
                            "SS",
                            "SD",
                            "SR",
                            "SJ",
                            "SZ",
                            "SY",
                            "TJ",
                            "TZ",
                            "TL",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TM",
                            "TC",
                            "TV",
                            "UG",
                            "UM",
                            "UY",
                            "UZ",
                            "VU",
                            "VG",
                            "VI",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "Country to analyze interest in. Choose \"Worldwide\" to see interest broken down by country; choose a country to see state/city breakdown (only larger countries expose subregion data).",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "0",
                            "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": "Google Trends category to filter by.",
                        "default": "0"
                    },
                    "viewedFrom": {
                        "title": "View Trends from",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "br",
                            "mx",
                            "in",
                            "jp",
                            "kr",
                            "ru",
                            "tr",
                            "pl",
                            "se",
                            "ie",
                            "be",
                            "ch",
                            "at",
                            "pt",
                            "gr",
                            "cz",
                            "il",
                            "ae",
                            "sa",
                            "za",
                            "id",
                            "ph",
                            "th",
                            "vn",
                            "my",
                            "sg",
                            "hk",
                            "tw",
                            "nz",
                            "cl",
                            "co",
                            "ar",
                            "ua"
                        ],
                        "type": "string",
                        "description": "Country to fetch Google Trends from. Pick the country your end users are in for geographically-accurate trends. Defaults to the United States.",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of dataset items returned. Set to 0 for no limit.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
