# Google Trends Scraper - Reliable Trends Data API (`webdatalabs/google-trends-reliable`) Actor

Reliable Google Trends data: interest over time, related queries & topics, interest by region. Consistent cross-query scaling, automatic retries, and no charges for empty results.

- **URL**: https://apify.com/webdatalabs/google-trends-reliable.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** Developer tools, SEO tools, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $7.00 / 1,000 trends results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Google Trends Scraper - Reliable Trends Data API

**Reliable Google Trends data API** for interest over time, related queries, and interest by region — with **consistent cross-query scaling** and **no charges for empty results**. Built for teams who got burned by Trends scrapers that break silently, never retry, and bill you for blank rows.

Compare up to 5 search terms on one valid 0–100 scale, export to CSV/JSON/Excel, or pull via API into n8n, Make, and Zapier. No coding required.

### 🆚 Why Choose This Google Trends Scraper?

| | This Actor | Typical Trends Scrapers |
|---|---|---|
| Retries & backoff | ✅ Automatic, residential IP rotation | ❌ Fail on first 429 |
| Charges for empty results | ✅ Never — `no_data` rows are free | ❌ Bill you for blanks |
| Cross-term scaling | ✅ All terms in one request (valid) | ❌ Separate requests (invalid) |
| Browser-grade requests | ✅ Real TLS fingerprint, gets through | ❌ Plain HTTP, blocked |
| Null-free output | ✅ Empty arrays, never `null` | ❌ Inconsistent shapes |

### ✨ Key Features

- **Interest over time** — normalized 0–100 search interest as a clean time series.
- **Related queries** — top **and rising** queries (rising = early demand signal).
- **Interest by region** — per-country/region interest, sorted high to low.
- **Consistent scaling** — compare up to 5 terms on one shared 0–100 scale.
- **Reliability first** — retries, exponential backoff, country-matched residential proxies.
- **Fair billing** — you only pay for terms that return real data.

### 🎯 Use Cases

#### SEO & Content Strategy
```json
{
  "searchTerms": ["ai writing", "ai seo"],
  "geo": "US",
  "timeRange": "today 12-m",
  "dataTypes": ["relatedQueries"]
}
````

**Result:** Spot rising queries before they peak and build content around real, growing demand.

#### Market Research & Brand Comparison

```json
{
  "searchTerms": ["nike", "adidas", "new balance"],
  "geo": "US",
  "timeRange": "today 5-y",
  "dataTypes": ["interestByRegion"]
}
```

**Result:** Compare brands on one valid 0–100 scale and see where each is strongest by region.

#### Product Validation & Trading Signals

```json
{
  "searchTerms": ["bitcoin", "ethereum"],
  "geo": "",
  "timeRange": "today 3-m",
  "dataTypes": ["relatedQueries"]
}
```

**Result:** Track worldwide attention and momentum for tickers, products, or themes over time.

### 📥 Input Configuration

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array (1–5) | `["coffee","tea"]` | **Required.** Terms to fetch/compare. |
| `geo` | string | `""` (Worldwide) | Location: Worldwide, a country, or a region code (e.g. `US-CA`). |
| `timeRange` | string | `today 3-m` | `now 1-d` … `today 5-y`, or `all` (since 2004). |
| `category` | string | `0` (All) | Restrict to a Google Trends category. |
| `dataTypes` | array | both | `relatedQueries`, `interestByRegion`. Interest over time is always included. |
| `customTimeRange` | string | – | *(Advanced)* Overrides `timeRange`, e.g. `2024-01-01 2024-06-30`. |
| `language` | string | `en-US` | Locale for labels and date bucketing. |
| `proxyConfiguration` | object | residential | *(Advanced)* Defaults to country-matched Apify residential proxies. |

> **Why max 5 terms?** Google Trends only normalizes up to 5 terms together in a single request. Comparing terms across separate requests is not statistically valid, so this actor caps at 5 by design — your comparisons stay meaningful.

### 📤 Output Schema

One **flat record per search term**. No field is ever `null` — missing data is an empty array, and numeric summaries default to `0` (the `status` field tells you which).

```json
{
  "searchTerm": "coffee",
  "geo": "US",
  "geoLabel": "United States",
  "timeRange": "today 12-m",
  "category": 0,
  "status": "ok",
  "scalingBasis": "Values are normalized 0-100 across all compared terms (coffee, tea) over today 12-m. Cross-term comparison is valid because every term was fetched in a single request.",
  "interestOverTime": [{ "date": "2025-07-06", "value": 71 }],
  "averageInterest": 69.5,
  "latestInterest": 68,
  "relatedQueries": {
    "top": [{ "query": "iced coffee", "value": 100, "link": "https://trends.google.com/trends/explore?q=iced+coffee" }],
    "rising": [{ "query": "coffee near me", "value": "Breakout", "link": "https://trends.google.com/trends/explore?q=coffee+near+me" }]
  },
  "interestByRegion": [{ "geoName": "Hawaii", "geoCode": "US-HI", "value": 100 }],
  "scrapedAt": "2026-06-30T12:00:00.000Z"
}
```

| Field | Type | Description |
|---|---|---|
| `searchTerm` | string | The term this record reports on. |
| `geoLabel` / `geo` | string | Human-readable location / geo code. |
| `timeRange` | string | Time range used. |
| `status` | string | `ok` (has data, billed) or `no_data` (free, never charged). |
| `scalingBasis` | string | What the 0–100 values are normalized against. |
| `interestOverTime` | array | `{ date, value }` time series (0–100). |
| `averageInterest` / `latestInterest` | number | Mean and most-recent interest (0 if no data). |
| `relatedQueries` | object | `{ top[], rising[] }` with `query`, `value`, `link`. |
| `interestByRegion` | array | `{ geoName, geoCode, value }`, sorted high to low. |

#### 📊 Dataset Views

The run page ships three ready-made views: **Overview** (key columns), **Interest Timeline** (one row per date for charting), and **Full Data**.

### 💰 Pricing

**Pay per result.** You are charged once per term that returns real interest-over-time data — so a successful 5-term comparison is 5 results. **Empty (`no_data`) terms and failed runs are never charged.** Standard Apify platform usage (compute + residential proxy bandwidth) is billed separately by Apify.

### 🛡️ Reliability & Anti-Blocking

Google Trends rate-limits and fingerprints aggressively. This actor is built to get through:

- **Browser-grade requests** with a real TLS fingerprint (not plain HTTP that Google blocks).
- **Country-matched residential proxies** — the exit IP matches your `geo`, which Google blocks far less.
- **Automatic retries** with exponential backoff and a fresh IP per attempt, so transient `429`s recover instead of failing.
- **Single-request comparison** keeps your 0–100 scale valid across terms.
- **Schema canary** — if Google changes its internal API, the run fails loudly (and free) instead of returning empty rows.

### 📅 Recommended Scheduling

Use Apify Schedules to track trends over time:

- **SEO/content:** weekly, with `relatedQueries` to catch rising terms early.
- **Market research:** monthly brand comparisons on `today 12-m`.
- **Trading signals:** daily on `now 7-d` for short-term momentum.

### ❓ FAQ

**Is this legal?** It accesses the same public Google Trends data your browser sees. You are responsible for complying with Google's Terms and applicable law.

**Why do I need residential proxies?** Google Trends throttles datacenter IPs within a few requests. Country-matched residential IPs are what keep runs reliable.

**Can I compare more than 5 terms?** No — Google only normalizes 5 terms together. Comparing across requests is invalid, so the actor caps at 5 to protect your data quality.

**What happens when a term has no data?** You get a record with `status: "no_data"` — and you are **not** charged for it.

**Can I use this with n8n, Make, or Zapier?** Yes. The flat, null-free output maps cleanly into automation tools, Google Sheets, and BigQuery.

### 🔗 Related Actors

| Actor | Description |
|---|---|
| [Reddit Scraper Pro](https://apify.com/webdatalabs/reddit-scraper-pro) | Posts, comments & sentiment for audience and demand research. |
| [Event Scraper Pro](https://apify.com/webdatalabs/event-scraper-pro) | Multi-platform event aggregation with webhooks. |

***

### 🏷️ SEO Keywords

google trends scraper, google trends api, google trends data, scrape google trends, google trends api alternative, interest over time api, related queries scraper, rising queries, interest by region, keyword trend data, search trends api, google trends export csv, google trends json, pytrends alternative, serpapi google trends alternative, market research api, seo trend analysis, product validation data, google trends automation, n8n google trends, google trends scheduler

***

### 📬 Custom Solutions & Enterprise

Need a custom data feed, modified output, or enterprise integration?

**Contact:** Furkanc58@gmail.com

- Daily/weekly data feeds (Snowflake, S3, BigQuery, Google Sheets)
- Custom scrapers for platforms not yet covered
- White-label solutions for agencies
- Priority support and SLAs

*Response within 24–48 hours.*

### Leave a review

Is this actor saving you time? A quick review on the Store helps other people find it — and tells us which fields to add next. **[Rate this actor →](https://apify.com/webdatalabs/google-trends-reliable)**

### Legal Disclaimer

This actor is a general-purpose tool for analyzing publicly accessible web data. The user bears sole responsibility for ensuring their specific use complies with applicable laws (including GDPR/DSGVO and copyright law), the target website's Terms of Service, and Apify's Terms of Service. The provider (webdatalabs) expressly disclaims liability for any unauthorized or unlawful use.

***

*This tool is not affiliated with or endorsed by Google. "Google Trends" and "Google" are trademarks of Google LLC. All trademarks belong to their respective owners.*

# Actor input Schema

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

1-5 terms. With 2-5 terms the interest values are normalized against each other so the comparison is valid (consistent scaling).

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

Region for the data. Leave as Worldwide, pick a country, or type a region code in the Advanced section (e.g. US-CA).

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

How far back to fetch interest data.

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

Restrict results to a Google Trends category. 0 = all categories.

## `dataTypes` (type: `array`):

Interest over time is always returned. Select any extra data blocks to include.

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

Overrides Time Range. Use Google's native syntax, e.g. "2024-01-01 2024-06-30", "today 45-d", or "now 123-H".

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

Locale used for labels and date bucketing (e.g. en-US, de-DE).

## `useApifyProxy` (type: `boolean`):

Strongly recommended. Google Trends rate-limits per IP; rotating residential IPs keep runs reliable.

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

Defaults to Apify residential proxies. Override only if you know what you need.

## Actor input object example

```json
{
  "searchTerms": [
    "coffee",
    "tea"
  ],
  "geo": "",
  "timeRange": "today 3-m",
  "category": "0",
  "dataTypes": [
    "relatedQueries",
    "interestByRegion"
  ],
  "language": "en-US",
  "useApifyProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

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

No description

## `full_data` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "coffee",
        "tea"
    ],
    "dataTypes": [
        "relatedQueries",
        "interestByRegion"
    ],
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/google-trends-reliable").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": [
        "coffee",
        "tea",
    ],
    "dataTypes": [
        "relatedQueries",
        "interestByRegion",
    ],
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/google-trends-reliable").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": [
    "coffee",
    "tea"
  ],
  "dataTypes": [
    "relatedQueries",
    "interestByRegion"
  ],
  "language": "en-US"
}' |
apify call webdatalabs/google-trends-reliable --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper - Reliable Trends Data API",
        "description": "Reliable Google Trends data: interest over time, related queries & topics, interest by region. Consistent cross-query scaling, automatic retries, and no charges for empty results.",
        "version": "1.0",
        "x-build-id": "K7jPsH1iUFaIsnIcL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~google-trends-reliable/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-google-trends-reliable",
                "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/webdatalabs~google-trends-reliable/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-google-trends-reliable",
                "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/webdatalabs~google-trends-reliable/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-google-trends-reliable",
                "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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "minItems": 1,
                        "maxItems": 5,
                        "type": "array",
                        "description": "1-5 terms. With 2-5 terms the interest values are normalized against each other so the comparison is valid (consistent scaling).",
                        "default": [
                            "coffee",
                            "tea"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "geo": {
                        "title": "Location",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "CA",
                            "AU",
                            "IN",
                            "BR",
                            "JP",
                            "ES",
                            "IT",
                            "NL"
                        ],
                        "type": "string",
                        "description": "Region for the data. Leave as Worldwide, pick a country, or type a region code in the Advanced section (e.g. US-CA).",
                        "default": ""
                    },
                    "timeRange": {
                        "title": "Time Range",
                        "enum": [
                            "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 fetch interest data.",
                        "default": "today 3-m"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "0",
                            "3",
                            "5",
                            "7",
                            "12",
                            "13",
                            "18",
                            "20",
                            "45",
                            "71",
                            "988"
                        ],
                        "type": "string",
                        "description": "Restrict results to a Google Trends category. 0 = all categories.",
                        "default": "0"
                    },
                    "dataTypes": {
                        "title": "Extra Data to Include",
                        "type": "array",
                        "description": "Interest over time is always returned. Select any extra data blocks to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "relatedQueries",
                                "interestByRegion"
                            ],
                            "enumTitles": [
                                "Related queries (top + rising)",
                                "Interest by region"
                            ]
                        },
                        "default": [
                            "relatedQueries",
                            "interestByRegion"
                        ]
                    },
                    "customTimeRange": {
                        "title": "Custom Time Range",
                        "type": "string",
                        "description": "Overrides Time Range. Use Google's native syntax, e.g. \"2024-01-01 2024-06-30\", \"today 45-d\", or \"now 123-H\"."
                    },
                    "language": {
                        "title": "Language / Locale",
                        "type": "string",
                        "description": "Locale used for labels and date bucketing (e.g. en-US, de-DE).",
                        "default": "en-US"
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Strongly recommended. Google Trends rate-limits per IP; rotating residential IPs keep runs reliable.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Defaults to Apify residential proxies. Override only if you know what you need.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
