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

Fast, reliable Google Trends data — interest over time, interest by region, related queries & topics for any keyword, plus daily trending searches. Built-in rate-limit handling. Any country, category, time range.

- **URL**: https://apify.com/native\_emblem/google-trends-scraper.md
- **Developed by:** [Magpie](https://apify.com/native_emblem) (community)
- **Categories:** SEO tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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 — reliable trends data without the rate-limit pain

Get clean, structured **Google Trends** data for any keyword: **interest over
time, interest by region, related queries, related topics**, and today's
**trending searches** — for any country, category, and time range.

Built for reliability: Google throttles Trends aggressively (HTTP 429), and
most scrapers just fail. This one handles it — automatic session rotation,
smart backoff, per-section retries, and parallel processing — so your runs finish.

> **Benchmark — 50-keyword run:** ✅ **100% success** (50/50 keywords) · 🧩 **100% section completeness** (timeline + regions + related queries on every record) · ⚡ **~6 s per keyword** · 🌐 unicode & special characters verified (ラーメン, भारत, C++, AT&T)

Perfect for **SEO & keyword research, content planning, market research,
product-demand validation, stock/crypto sentiment, newsjacking, and trend
monitoring dashboards**.

---

### ✨ Why this scraper

- **It finishes runs.** Built-in 429 handling: fresh IP + fresh Google session on every throttle, exponential backoff, per-request pacing.
- **All four sections** per keyword: interest over time, interest by region (countries / subregions / cities / metros), related queries (top & rising), related topics (top & rising).
- **Trending Now included.** Daily trending searches for any country — with traffic estimates and the news stories driving each trend.
- **Any slice of Trends.** All time ranges (past hour → 2004-present, plus custom dates), all countries and regions, all categories, and all properties (Web, Image, News, YouTube, Shopping search).
- **Clean output.** One tidy record per keyword — ISO dates, plain numbers, no `)]}'` junk. Ready for Sheets, a DB, or your app.
- **Fair pricing.** Pay per keyword actually scraped, not per run-hour. Failed keywords are never billed — guaranteed in code.
- **Fast.** Parallel keyword processing (configurable concurrency), ~6 s per keyword in benchmark.

### 📥 Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | string[] | Keywords to analyse — one dataset record each. |
| `timeRange` | enum | `now 1-H` … `today 12-m` (default) … `all`. |
| `customTimeRange` | string | Custom dates: `"2025-01-01 2025-06-30"` (overrides `timeRange`). |
| `geo` | string | Country (`US`, `GB`, `DE`…) or region (`US-CA`). Empty = worldwide. |
| `category` | integer | Trends category ID (0 = all). |
| `property` | enum | Web (default), `images`, `news`, `youtube`, `froogle` (Shopping). |
| `includeInterestOverTime` / `includeInterestByRegion` / `includeRelatedQueries` / `includeRelatedTopics` | boolean | Toggle sections (all on by default). |
| `regionResolution` | enum | Region breakdown: `AUTO`, `COUNTRY`, `REGION`, `CITY`, `DMA`. |
| `trendingNow` | boolean | Also scrape today's trending searches. |
| `trendingGeos` | string[] | Countries for trending searches (default `["US"]`). |
| `language` | string | Locale for labels (`en-US` default). |
| `maxItems` | integer | Stop after N records. |
| `proxyConfiguration` | object | Apify Proxy (default) — strongly recommended. |

#### Example input

```json
{
  "searchTerms": ["bitcoin", "ethereum"],
  "timeRange": "today 12-m",
  "geo": "US",
  "trendingNow": true,
  "trendingGeos": ["US", "GB"]
}
````

### 📤 Output

One record per search term:

```json
{
  "term": "bitcoin",
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "interestOverTime": [
    { "date": "2025-07-06T00:00:00.000Z", "formattedDate": "Jul 6 – 12, 2025", "value": 37 }
  ],
  "averageInterest": 44.3,
  "interestByRegion": [
    { "geoCode": "US-NV", "geoName": "Nevada", "value": 100 }
  ],
  "relatedQueries": {
    "top": [{ "query": "bitcoin price", "value": 100, "formattedValue": "100" }],
    "rising": [{ "query": "bitcoin etf", "value": 250, "formattedValue": "+250%" }]
  },
  "relatedTopics": {
    "top": [{ "topicTitle": "Bitcoin", "topicType": "Cryptocurrency", "value": 100 }],
    "rising": []
  },
  "scrapedAt": "2026-07-08T12:00:00.000Z"
}
```

And one record per trending story (when `trendingNow` is on):

```json
{
  "type": "trending",
  "query": "norway team sick",
  "approxTraffic": "500+",
  "geo": "US",
  "startedAt": "2026-07-08T17:30:00.000Z",
  "picture": "https://encrypted-tbn3.gstatic.com/images?q=…",
  "pictureSource": "Reuters",
  "newsItems": [
    { "title": "Norway struggle to stay healthy…", "url": "https://www.reuters.com/…", "source": "Reuters" }
  ],
  "scrapedAt": "2026-07-08T12:00:00.000Z"
}
```

Export as **JSON, CSV, Excel**, or pull via the **Apify API** — and schedule
runs to build your own trends history (Google only shows relative values;
scheduled snapshots give you an absolute archive).

### ❓ FAQ

**Why are values 0–100 instead of absolute search volumes?**
Google Trends only publishes *relative* interest, normalised to the highest
point in the selected period. That's true for trends.google.com too — no tool
can get absolute volumes from Trends.

**Can I compare keywords?**
Each term is scraped independently (normalised to itself). To compare, scrape
both terms and align the series, or use rising/top values within one record.

**Why is the city-level breakdown sometimes empty?**
Same reason as related topics below — Google serves city granularity
selectively to automated sessions. Country, subregion (state), and US metro
(DMA) breakdowns always return full data.

**Why are related topics sometimes empty?**
Google serves the related-*topics* section selectively and suppresses it for
most automated sessions (this affects every Trends scraper on the market —
try them). Related *queries*, interest over time, and regional data are not
affected.

**Which countries are supported?**
All of them — anything Google Trends supports, including subregions (`US-CA`)
and metro areas (DMA) for the region breakdown.

**Does it work for YouTube / Shopping / News trends?**
Yes — set `property` to `youtube`, `froogle`, `news`, or `images`.

**Is scraping Google Trends legal?**
The actor collects only public, aggregated, anonymised data — no personal
information. Review your own use case and local rules as usual.

### 🔧 Integrations

Works with everything on the Apify platform: **Google Sheets, Zapier, Make,
n8n, Airbyte, webhooks**, or the [Apify API](https://docs.apify.com/api/v2)
(Node.js & Python clients). Schedule daily runs to track keyword momentum or
pipe Trending Now into your content workflow.

### 🏷️ Keywords

google trends api, google trends scraper, keyword trends, search interest data,
trending searches scraper, related queries api, keyword research tool, SEO
trends data, google trends export, interest over time api

# Actor input Schema

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

Keywords to look up on Google Trends. Each term produces one dataset record with interest over time, interest by region, related queries and related topics. Values are relative (0–100) within each term.

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

Period to analyse.

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

Overrides Time range. Format: "YYYY-MM-DD YYYY-MM-DD", e.g. "2025-01-01 2025-06-30".

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

Two-letter country code (US, GB, DE…) or region code (US-CA). Leave empty for worldwide.

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

Google Trends category ID to narrow results (0 = all categories). E.g. 7 = Finance, 8 = Games, 16 = News, 45 = Health, 3 = Arts & Entertainment.

## `property` (type: `string`):

Which Google property to analyse.

## `includeInterestOverTime` (type: `boolean`):

Include the interest-over-time series (0–100 per time bucket).

## `includeInterestByRegion` (type: `boolean`):

Include the geographic breakdown of interest.

## `includeRelatedQueries` (type: `boolean`):

Include top & rising related search queries.

## `includeRelatedTopics` (type: `boolean`):

Include top & rising related topics.

## `regionResolution` (type: `string`):

Granularity of Interest by region. AUTO lets Google pick (countries for worldwide, subregions for a country). COUNTRY, REGION and DMA (US metro areas) return full data; CITY is served selectively by Google and can come back empty.

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

Also fetch today's trending searches (Trending Now) — one record per trending story with traffic estimate and news links.

## `trendingGeos` (type: `array`):

Country codes to fetch trending searches for (used only when Scrape trending searches is on).

## `concurrency` (type: `integer`):

How many search terms to process in parallel (1–10). Higher = faster runs; each term uses its own proxy session, so parallelism is safe.

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

Locale for formatted labels and topic names (hl parameter).

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

Stop after pushing this many records. Leave empty for no limit.

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

Google throttles Trends heavily per IP. RESIDENTIAL proxies are strongly recommended — datacenter IPs are widely blocked by Google and will produce mostly failed terms.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin"
  ],
  "timeRange": "today 12-m",
  "geo": "US",
  "category": 0,
  "property": "",
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeRelatedQueries": true,
  "includeRelatedTopics": true,
  "regionResolution": "AUTO",
  "trendingNow": false,
  "trendingGeos": [
    "US"
  ],
  "concurrency": 5,
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One record per search term (interest over time, interest by region, related queries & topics) and per trending story.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper",
        "description": "Fast, reliable Google Trends data — interest over time, interest by region, related queries & topics for any keyword, plus daily trending searches. Built-in rate-limit handling. Any country, category, time range.",
        "version": "0.1",
        "x-build-id": "eMpeQ941UdGETJkV6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/native_emblem~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-native_emblem-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/native_emblem~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-native_emblem-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/native_emblem~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-native_emblem-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": "Keywords to look up on Google Trends. Each term produces one dataset record with interest over time, interest by region, related queries and related topics. Values are relative (0–100) within each term.",
                        "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": "Period to analyse.",
                        "default": "today 12-m"
                    },
                    "customTimeRange": {
                        "title": "Custom time range",
                        "type": "string",
                        "description": "Overrides Time range. Format: \"YYYY-MM-DD YYYY-MM-DD\", e.g. \"2025-01-01 2025-06-30\"."
                    },
                    "geo": {
                        "title": "Location",
                        "type": "string",
                        "description": "Two-letter country code (US, GB, DE…) or region code (US-CA). Leave empty for worldwide."
                    },
                    "category": {
                        "title": "Category",
                        "type": "integer",
                        "description": "Google Trends category ID to narrow results (0 = all categories). E.g. 7 = Finance, 8 = Games, 16 = News, 45 = Health, 3 = Arts & Entertainment.",
                        "default": 0
                    },
                    "property": {
                        "title": "Search type",
                        "enum": [
                            "",
                            "images",
                            "news",
                            "youtube",
                            "froogle"
                        ],
                        "type": "string",
                        "description": "Which Google property to analyse.",
                        "default": ""
                    },
                    "includeInterestOverTime": {
                        "title": "Interest over time",
                        "type": "boolean",
                        "description": "Include the interest-over-time series (0–100 per time bucket).",
                        "default": true
                    },
                    "includeInterestByRegion": {
                        "title": "Interest by region",
                        "type": "boolean",
                        "description": "Include the geographic breakdown of interest.",
                        "default": true
                    },
                    "includeRelatedQueries": {
                        "title": "Related queries",
                        "type": "boolean",
                        "description": "Include top & rising related search queries.",
                        "default": true
                    },
                    "includeRelatedTopics": {
                        "title": "Related topics",
                        "type": "boolean",
                        "description": "Include top & rising related topics.",
                        "default": true
                    },
                    "regionResolution": {
                        "title": "Region breakdown level",
                        "enum": [
                            "AUTO",
                            "COUNTRY",
                            "REGION",
                            "CITY",
                            "DMA"
                        ],
                        "type": "string",
                        "description": "Granularity of Interest by region. AUTO lets Google pick (countries for worldwide, subregions for a country). COUNTRY, REGION and DMA (US metro areas) return full data; CITY is served selectively by Google and can come back empty.",
                        "default": "AUTO"
                    },
                    "trendingNow": {
                        "title": "Scrape trending searches",
                        "type": "boolean",
                        "description": "Also fetch today's trending searches (Trending Now) — one record per trending story with traffic estimate and news links.",
                        "default": false
                    },
                    "trendingGeos": {
                        "title": "Trending locations",
                        "type": "array",
                        "description": "Country codes to fetch trending searches for (used only when Scrape trending searches is on).",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many search terms to process in parallel (1–10). Higher = faster runs; each term uses its own proxy session, so parallelism is safe.",
                        "default": 5
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Locale for formatted labels and topic names (hl parameter).",
                        "default": "en-US"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after pushing this many records. Leave empty for no limit."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Google throttles Trends heavily per IP. RESIDENTIAL proxies are strongly recommended — datacenter IPs are widely blocked by Google and will produce mostly failed terms.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
