# Google Trends Radar — Batch Keywords & Trending Now (`primevision/google-trends-radar`) Actor

Batch Google Trends scraper: interest over time, interest by region, related queries & topics for hundreds of keywords per run, plus real-time trending searches with volume. Smart backoff + session rotation for reliability. Pay per result.

- **URL**: https://apify.com/primevision/google-trends-radar.md
- **Developed by:** [Prime Vision](https://apify.com/primevision) (community)
- **Categories:** News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 keyword results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Radar

Batch-first Google Trends scraper built for reliability. Feed it **hundreds of
keywords in one run** and get back clean, normalized JSON for:

- **Interest over time** — the classic 0–100 curve, with average / latest / peak
  summary fields precomputed for spreadsheets and dashboards
- **Interest by region** — countries, states, cities or US metro areas
- **Related queries** — top & rising, the dataset Google throttles hardest
- **Related topics** — top & rising entities
- **Trending now** — real-time trending searches with approximate search volume,
  growth %, start time and related terms (up to ~500 active trends per country)

Google has no official Trends API (the announced one is a wait-listed alpha).
This actor speaks to the same internal endpoints the trends.google.com website
uses, wrapped in the thing that actually matters: **smart backoff, session
rotation and per-item fault isolation**, so one blocked request never kills your
batch.

### Why this one

| Pain with other Trends scrapers | Google Trends Radar |
| --- | --- |
| One keyword per run, or brittle CSV uploads | Native batch: keyword list × timeframe list in a single run |
| Random 429 crashes | Every request retried with fresh session + exponential backoff; failures isolated per item |
| Empty datasets, silent failures | Failed items are reported as explicit `error` rows — and you are **not charged** for them |
| Pay for a monthly rental you use twice | Pay per delivered result row |

### Input example

```json
{
    "keywords": ["standing desk", "ergonomic chair", "walking pad"],
    "dataTypes": ["interest_over_time", "related_queries"],
    "timeframes": ["today 3-m", "today 12-m"],
    "geo": "US",
    "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

Every keyword is scaled independently (0–100) by default — ideal for keyword
research. Flip `compareKeywords` on to get the same shared-scale comparison the
Google Trends website shows.

### Output examples

Interest over time (one row per keyword × timeframe):

```json
{
    "dataType": "interest_over_time",
    "keyword": "standing desk",
    "geo": "US",
    "timeframe": "today 3-m",
    "averageValue": 62.4,
    "latestValue": 71,
    "peakValue": 100,
    "peakDate": "2026-06-14T00:00:00+00:00",
    "timeline": [
        { "date": "2026-04-21T00:00:00+00:00", "value": 55, "isPartial": false }
    ]
}
```

Related queries:

```json
{
    "dataType": "related_queries",
    "keyword": "standing desk",
    "top": [ { "query": "best standing desk", "value": 100 } ],
    "rising": [ { "query": "walking pad standing desk", "value": 350, "formattedValue": "+350%" } ]
}
```

Trending now:

```json
{
    "dataType": "trending_now",
    "query": "alaska airlines emergency",
    "geo": "US",
    "startedAt": "2026-07-19T22:30:00+00:00",
    "approxSearchVolume": 200000,
    "volumeGrowthPct": 1000,
    "relatedTerms": ["alaska airlines", "boeing 787"]
}
```

### Scheduling (what this actor is built for)

Add an [Apify Schedule](https://docs.apify.com/platform/schedules) and the actor
becomes a monitoring pipeline: track your niche's keywords daily, export to
Google Sheets, or push rows to Zapier/Make via the dataset API. Typical setups:

- **SEO agency**: 200 client keywords, `today 3-m`, daily at 07:00 — spot
  breakout queries before competitors write the content.
- **E-commerce**: category terms + `related_queries` weekly — mine rising
  queries for product listings.
- **Newsroom / social**: `trending_now` every 30 min with `trendingHours: 4`.

### Pricing

Pay per event: a small start fee per run, then a fixed price **per delivered
result row** (`keyword-result` for keyword datasets, `trending-term` for
trending rows). Failed items are free and clearly marked. Rows where Google
returned an empty result set (e.g. related data for a very niche keyword) are
delivered **free of charge** — you only pay for rows that contain data. No
subscription.

### Tips for reliability

- Use **residential proxy** (default). Google throttles datacenter IPs hard,
  and *related queries* is the strictest dataset — on datacenter IPs it may
  fail even with retries.
- Keep `concurrency` at 2 unless your batch is small.
- Very large batches (500+ keyword × timeframe units) are capped per run —
  split them across scheduled runs.

### Legal note

This actor extracts publicly available data from Google Trends. You are
responsible for how you use the data. Numbers are Google's relative indices,
not absolute search volumes (except trending-now approximate volume, which is
Google's own estimate).

# Actor input Schema

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

Any number of search terms — the actor works through the whole list with smart pacing and retries. Not needed if you only want trending searches.

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

Which Google Trends datasets to fetch for each keyword. 'Trending now' ignores keywords and returns what is trending right now in the selected country.

## `timeframes` (type: `array`):

One or more Google Trends time ranges — each keyword is fetched for every timeframe listed. Supported: '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', or a custom range 'YYYY-MM-DD YYYY-MM-DD'.

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

Two-letter country code (e.g. 'US', 'GB', 'DE'), region code (e.g. 'US-NY'), or empty for worldwide. Note: 'Trending now' has no worldwide mode — with empty geo it falls back to US.

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

Google Trends category to filter by (0 = all categories). Examples: 7 Finance, 8 Games, 12 Business & Industrial, 13 Internet & Telecom, 16 News, 18 Shopping, 20 Sports, 45 Health, 71 Food & Drink. Full list: https://github.com/pat310/google-trends-api/wiki/Google-Trends-Categories

## `searchProperty` (type: `string`):

Which Google property to measure search interest on.

## `compareKeywords` (type: `boolean`):

OFF (default): every keyword is scaled independently 0-100 — best for batch keyword research. ON: keywords are compared in groups of 5 on a shared scale, like the compare feature on the Google Trends website.

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

Granularity for 'Interest by region'. AUTO = regions for a country, countries for worldwide.

## `trendingHours` (type: `integer`):

For 'Trending now': how far back the trend may have started. Use 4, 24, 48 or 168 (7 days).

## `maxTrendingItems` (type: `integer`):

Cap on 'Trending now' rows returned (Google typically has 300-500 active trends).

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

Language hint for trending searches (e.g. 'en', 'de', 'pl').

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

Parallel workers, each with its own proxy session. Keep low — Google rate-limits aggressively; 2 is a good balance of speed and reliability.

## `maxRetriesPerRequest` (type: `integer`):

How many times a single API call is retried with a fresh session and exponential backoff before the item is reported as failed.

## `proxy` (type: `object`):

Google throttles datacenter IPs heavily — residential proxy strongly recommended, especially for related queries.

## Actor input object example

```json
{
  "keywords": [
    "chatgpt",
    "google gemini"
  ],
  "dataTypes": [
    "interest_over_time",
    "related_queries"
  ],
  "timeframes": [
    "today 12-m"
  ],
  "geo": "US",
  "category": 0,
  "searchProperty": "",
  "compareKeywords": false,
  "regionResolution": "AUTO",
  "trendingHours": 24,
  "maxTrendingItems": 50,
  "language": "en",
  "concurrency": 2,
  "maxRetriesPerRequest": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "chatgpt",
        "google gemini"
    ],
    "dataTypes": [
        "interest_over_time",
        "related_queries"
    ],
    "timeframes": [
        "today 12-m"
    ],
    "geo": "US",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("primevision/google-trends-radar").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "chatgpt",
        "google gemini",
    ],
    "dataTypes": [
        "interest_over_time",
        "related_queries",
    ],
    "timeframes": ["today 12-m"],
    "geo": "US",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("primevision/google-trends-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "chatgpt",
    "google gemini"
  ],
  "dataTypes": [
    "interest_over_time",
    "related_queries"
  ],
  "timeframes": [
    "today 12-m"
  ],
  "geo": "US",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call primevision/google-trends-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Radar — Batch Keywords & Trending Now",
        "description": "Batch Google Trends scraper: interest over time, interest by region, related queries & topics for hundreds of keywords per run, plus real-time trending searches with volume. Smart backoff + session rotation for reliability. Pay per result.",
        "version": "0.1",
        "x-build-id": "ofWKDJ0EOCteGZjhE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/primevision~google-trends-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-primevision-google-trends-radar",
                "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/primevision~google-trends-radar/runs": {
            "post": {
                "operationId": "runs-sync-primevision-google-trends-radar",
                "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/primevision~google-trends-radar/run-sync": {
            "post": {
                "operationId": "run-sync-primevision-google-trends-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords (batch)",
                        "type": "array",
                        "description": "Any number of search terms — the actor works through the whole list with smart pacing and retries. Not needed if you only want trending searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataTypes": {
                        "title": "Data to fetch",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which Google Trends datasets to fetch for each keyword. 'Trending now' ignores keywords and returns what is trending right now in the selected country.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "interest_over_time",
                                "interest_by_region",
                                "related_queries",
                                "related_topics",
                                "trending_now"
                            ],
                            "enumTitles": [
                                "Interest over time",
                                "Interest by region",
                                "Related queries",
                                "Related topics",
                                "Trending now (real-time)"
                            ]
                        },
                        "default": [
                            "interest_over_time"
                        ]
                    },
                    "timeframes": {
                        "title": "Timeframes",
                        "type": "array",
                        "description": "One or more Google Trends time ranges — each keyword is fetched for every timeframe listed. Supported: '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', or a custom range 'YYYY-MM-DD YYYY-MM-DD'.",
                        "default": [
                            "today 12-m"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "geo": {
                        "title": "Location (geo)",
                        "type": "string",
                        "description": "Two-letter country code (e.g. 'US', 'GB', 'DE'), region code (e.g. 'US-NY'), or empty for worldwide. Note: 'Trending now' has no worldwide mode — with empty geo it falls back to US.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category ID",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Google Trends category to filter by (0 = all categories). Examples: 7 Finance, 8 Games, 12 Business & Industrial, 13 Internet & Telecom, 16 News, 18 Shopping, 20 Sports, 45 Health, 71 Food & Drink. Full list: https://github.com/pat310/google-trends-api/wiki/Google-Trends-Categories",
                        "default": 0
                    },
                    "searchProperty": {
                        "title": "Search property",
                        "enum": [
                            "",
                            "images",
                            "news",
                            "youtube",
                            "froogle"
                        ],
                        "type": "string",
                        "description": "Which Google property to measure search interest on.",
                        "default": ""
                    },
                    "compareKeywords": {
                        "title": "Compare keywords against each other",
                        "type": "boolean",
                        "description": "OFF (default): every keyword is scaled independently 0-100 — best for batch keyword research. ON: keywords are compared in groups of 5 on a shared scale, like the compare feature on the Google Trends website.",
                        "default": false
                    },
                    "regionResolution": {
                        "title": "Region breakdown level",
                        "enum": [
                            "AUTO",
                            "COUNTRY",
                            "REGION",
                            "CITY",
                            "DMA"
                        ],
                        "type": "string",
                        "description": "Granularity for 'Interest by region'. AUTO = regions for a country, countries for worldwide.",
                        "default": "AUTO"
                    },
                    "trendingHours": {
                        "title": "Trending window (hours)",
                        "minimum": 1,
                        "maximum": 168,
                        "type": "integer",
                        "description": "For 'Trending now': how far back the trend may have started. Use 4, 24, 48 or 168 (7 days).",
                        "default": 24
                    },
                    "maxTrendingItems": {
                        "title": "Max trending items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on 'Trending now' rows returned (Google typically has 300-500 active trends).",
                        "default": 50
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language hint for trending searches (e.g. 'en', 'de', 'pl').",
                        "default": "en"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Parallel workers, each with its own proxy session. Keep low — Google rate-limits aggressively; 2 is a good balance of speed and reliability.",
                        "default": 2
                    },
                    "maxRetriesPerRequest": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many times a single API call is retried with a fresh session and exponential backoff before the item is reported as failed.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Google throttles datacenter IPs heavily — residential proxy strongly recommended, especially for related queries.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
