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

Extract search interest data from Google Trends: interest over time, interest by region, related queries, and daily trending searches. Supports multiple keywords and countries in one run. No API key needed.

- **URL**: https://apify.com/rastriq/google-trends-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## Google Trends Scraper

Extract search interest data from Google Trends without an API key. Get interest over time, interest by region, related queries, and daily trending searches for any keyword across any country.

### What does Google Trends Scraper do?

This Actor extracts data from [Google Trends](https://trends.google.com/) using internal endpoints — no browser needed, making it fast and cheap to run.

For each keyword and country you provide, the scraper returns:

|  |  |
| --- | --- |
| :chart_with_upwards_trend: Interest over time | Weekly or daily search interest values (0-100 scale) |
| :world_map: Interest by region | Breakdown by state, province, or subregion |
| :mag: Related queries | Top and rising related search terms |
| :fire: Daily trending searches | What's trending right now via RSS feed |

All results are **flat, one-row-per-data-point** records that export cleanly to CSV or Excel. No nested JSON to untangle.

### How to use Google Trends Scraper

1. [Create](https://console.apify.com/sign-up) an Apify account (free tier available).
2. Open [Google Trends Scraper](https://apify.com/rastriq/google-trends-scraper).
3. Enter your keywords and select countries.
4. Click **Start** and wait for results (typically under 30 seconds).
5. Download your data in JSON, CSV, Excel, XML, or HTML.

#### Input example (keyword analysis)

Compare two keywords across three countries:

```json
{
  "keywords": ["artificial intelligence", "machine learning"],
  "geos": ["US", "ES", "DE"],
  "timeframe": "today 12-m"
}
````

#### Input example (with trending searches)

Get keyword analysis plus daily trending topics:

```json
{
  "keywords": ["bitcoin"],
  "geos": ["US", "GB"],
  "timeframe": "today 3-m",
  "includeTrending": true
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `keywords` | string\[] | *required* | Search terms to track. Up to 5 are compared per group. |
| `geos` | string\[] | `["US"]` | ISO country codes (e.g. `US`, `ES`, `DE`). Leave empty for worldwide. |
| `timeframe` | string | `today 12-m` | Time range for analysis. See table below. |
| `category` | integer | `0` | Google Trends category ID (0 = all categories). |
| `property` | string | Web Search | Google service: Web, Images, News, YouTube, or Shopping. |
| `includeTrending` | boolean | `false` | Also fetch daily trending searches for each country. |

#### Available time ranges

| Value | Period | Data granularity |
| --- | --- | --- |
| `now 1-H` | Past hour | Per minute |
| `now 4-H` | Past 4 hours | Per minute |
| `now 7-d` | Past 7 days | Daily |
| `today 1-m` | Past 30 days | Daily |
| `today 3-m` | Past 90 days | Daily |
| `today 12-m` | Past 12 months (default) | Weekly |
| `today 5-y` | Past 5 years | Weekly |
| `all` | Since 2004 | Monthly |
| `2024-01-01 2024-12-31` | Custom date range | Varies |

### Output

Each row in the dataset has a `dataType` field you can filter on. Here's what each type looks like:

#### `timeline` — Interest over time

```json
{
  "dataType": "timeline",
  "keyword": "artificial intelligence",
  "geo": "US",
  "date": "Jan 1 - 7, 2025",
  "timestamp": "1735689600",
  "value": 73,
  "timeframe": "today 12-m",
  "category": 0,
  "property": "web"
}
```

#### `geo` — Interest by region

```json
{
  "dataType": "geo",
  "keyword": "artificial intelligence",
  "geo": "US",
  "regionName": "California",
  "regionCode": "US-CA",
  "value": 100,
  "timeframe": "today 12-m"
}
```

#### `relatedQuery` — Related search terms

```json
{
  "dataType": "relatedQuery",
  "keyword": "artificial intelligence",
  "geo": "US",
  "query": "ai chatbot",
  "value": 100,
  "formattedValue": "100",
  "ranking": "top"
}
```

#### `trending` — Daily trending searches

```json
{
  "dataType": "trending",
  "geo": "US",
  "title": "ChatGPT update",
  "approxTraffic": "500K+",
  "pubDate": "Thu, 5 Jun 2026 10:00:00 -0700",
  "newsCount": 3,
  "news": [
    {
      "title": "ChatGPT launches new feature",
      "url": "https://example.com/article",
      "source": "TechCrunch"
    }
  ]
}
```

### How much does it cost?

This Actor charges **$0.30 per 1,000 results** (includes compute). No monthly subscription.

| Scenario | Results | Cost |
| --- | --- | --- |
| 1 keyword, 1 country | ~130 | ~$0.04 |
| 2 keywords, 3 countries | ~400 | ~$0.12 |
| 5 keywords, 10 countries | ~6,500 | ~$1.95 |

No proxy needed for small runs. For large-scale extraction, enable optional proxy rotation in Advanced options.

### What can you do with Google Trends data?

| Use case | How |
| --- | --- |
| :mag: **SEO & content strategy** | Find rising search terms to target with new content |
| :chart\_with\_upwards\_trend: **Market research** | Compare brand or product interest across countries |
| :loudspeaker: **Competitive analysis** | Track how competitor keywords trend vs. yours |
| :calendar: **Seasonal planning** | Identify when interest peaks for seasonal products |
| :bulb: **Idea validation** | Check if interest in a topic is growing or declining |

### Tips for best results

1. **Compare competitors** — put up to 5 brands or products in the keywords list to get comparative data.
2. **Use topic IDs** — instead of `"python"` (ambiguous: snake or language?), use topic ID `"/m/05z1_"` for Python the programming language. The autocomplete endpoint resolves these automatically.
3. **Pick the right timeframe** — need daily granularity? Use `today 3-m`. Need the big picture? Use `today 5-y` or `all`.
4. **Multi-country runs** — add all countries in one run instead of running separately. The scraper handles throttling between countries automatically.

### Integrations

Connect Google Trends Scraper to your workflow:

- **API** — call programmatically via [Apify API](https://apify.com/rastriq/google-trends-scraper/api) (Python, JavaScript, cURL)
- **Webhooks** — trigger actions when a run completes
- **Zapier / Make** — connect to 5,000+ apps
- **Google Sheets** — export directly to a spreadsheet
- **Schedule** — run daily, weekly, or monthly to track trends over time

### FAQ

#### Is there a Google Trends API?

Google does not offer a public API for Google Trends. This scraper acts as an unofficial API by extracting data from Google Trends' internal endpoints — the same ones the website uses.

#### How is this different from pytrends?

This scraper uses the same internal endpoints as pytrends, but runs in the cloud with automatic retries, proxy support, and multi-country batching. No Python environment needed.

#### Can I compare more than 5 keywords?

Google Trends limits comparisons to 5 keywords at a time. If you provide more than 5, the scraper automatically batches them into groups of 5. Note that values between different batches use different normalization scales.

#### Why are values 0-100 instead of actual search volumes?

Google Trends normalizes data to a 0-100 scale relative to the peak value in your selected timeframe and region. A value of 100 means peak popularity, not 100 searches. This is how Google Trends works — it's not a limitation of the scraper.

#### Is it legal to scrape Google Trends?

This scraper extracts publicly available data from Google Trends. However, always review Google's Terms of Service before using scraped data commercially.

### Your feedback

Found a bug? Need a feature? Please create an issue on the [Issues tab](https://apify.com/rastriq/google-trends-scraper/issues). We actively maintain this Actor and respond to all reports.

# Actor input Schema

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

Search terms to track. Add up to 5 keywords to compare them side by side (e.g. 'bitcoin', 'ethereum'). You can also use Google Trends topic IDs like '/m/05z1\_' for more precise matching.

## `geos` (type: `array`):

ISO country codes (e.g. 'US', 'ES', 'DE', 'GB', 'JP'). The scraper runs a separate analysis for each country. Leave empty for worldwide data.

## `timeframe` (type: `string`):

How far back to look. Shorter = daily data, longer = weekly. You can also type a custom date range like '2024-01-01 2024-12-31'.

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

Google Trends category ID. Use 0 for all categories. Find category IDs at Google Trends > select a category > check the URL for the 'cat' parameter.

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

Which Google service to analyze.

## `includeTrending` (type: `boolean`):

Also fetch today's trending searches for each country via Google's RSS feed. Adds ~10 trending topics per country with traffic estimates and related news articles.

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

Use 'Countries' field above instead. This is only used if the Countries list is empty.

## `hl` (type: `string`):

Language for Google Trends results (e.g. 'en-US', 'es', 'de', 'fr', 'ja').

## `tz` (type: `integer`):

Offset from UTC in minutes. Examples: 0 (UTC), -300 (US Eastern), -360 (US Central), 60 (Central Europe), 540 (Japan).

## `maxRetries` (type: `integer`):

How many times to retry on rate limits (429) or server errors (5xx). Uses exponential backoff.

## `rotateProxyPerGeo` (type: `boolean`):

Get a fresh proxy IP for each country. Reduces rate limiting on multi-country runs. Only works when proxy is configured below.

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

Optional. Recommended for runs with many keywords or countries. Without proxy, Google may rate-limit after ~10-15 rapid requests.

## Actor input object example

```json
{
  "keywords": [
    "python",
    "javascript"
  ],
  "geos": [
    "US"
  ],
  "timeframe": "today 12-m",
  "category": 0,
  "property": "",
  "includeTrending": false,
  "geo": "",
  "hl": "en-US",
  "tz": 0,
  "maxRetries": 3,
  "rotateProxyPerGeo": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": [
        "python",
        "javascript",
    ],
    "geos": ["US"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "python",
    "javascript"
  ],
  "geos": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call rastriq/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper",
        "description": "Extract search interest data from Google Trends: interest over time, interest by region, related queries, and daily trending searches. Supports multiple keywords and countries in one run. No API key needed.",
        "version": "0.1",
        "x-build-id": "KyesJHVguECYO8ceq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rastriq~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rastriq-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/rastriq~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rastriq-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/rastriq~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rastriq-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms to track. Add up to 5 keywords to compare them side by side (e.g. 'bitcoin', 'ethereum'). You can also use Google Trends topic IDs like '/m/05z1_' for more precise matching.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geos": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO country codes (e.g. 'US', 'ES', 'DE', 'GB', 'JP'). The scraper runs a separate analysis for each country. Leave empty for worldwide data.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeframe": {
                        "title": "Time range",
                        "enum": [
                            "now 1-H",
                            "now 4-H",
                            "now 7-d",
                            "today 1-m",
                            "today 3-m",
                            "today 12-m",
                            "today 5-y",
                            "all"
                        ],
                        "type": "string",
                        "description": "How far back to look. Shorter = daily data, longer = weekly. You can also type a custom date range like '2024-01-01 2024-12-31'.",
                        "default": "today 12-m"
                    },
                    "category": {
                        "title": "Category filter",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Google Trends category ID. Use 0 for all categories. Find category IDs at Google Trends > select a category > check the URL for the 'cat' parameter.",
                        "default": 0
                    },
                    "property": {
                        "title": "Google property",
                        "enum": [
                            "",
                            "images",
                            "news",
                            "youtube",
                            "froogle"
                        ],
                        "type": "string",
                        "description": "Which Google service to analyze.",
                        "default": ""
                    },
                    "includeTrending": {
                        "title": "Include daily trending searches",
                        "type": "boolean",
                        "description": "Also fetch today's trending searches for each country via Google's RSS feed. Adds ~10 trending topics per country with traffic estimates and related news articles.",
                        "default": false
                    },
                    "geo": {
                        "title": "Single country (legacy)",
                        "type": "string",
                        "description": "Use 'Countries' field above instead. This is only used if the Countries list is empty.",
                        "default": ""
                    },
                    "hl": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for Google Trends results (e.g. 'en-US', 'es', 'de', 'fr', 'ja').",
                        "default": "en-US"
                    },
                    "tz": {
                        "title": "Timezone offset (minutes)",
                        "type": "integer",
                        "description": "Offset from UTC in minutes. Examples: 0 (UTC), -300 (US Eastern), -360 (US Central), 60 (Central Europe), 540 (Japan).",
                        "default": 0
                    },
                    "maxRetries": {
                        "title": "Max retries per request",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry on rate limits (429) or server errors (5xx). Uses exponential backoff.",
                        "default": 3
                    },
                    "rotateProxyPerGeo": {
                        "title": "Rotate proxy per country",
                        "type": "boolean",
                        "description": "Get a fresh proxy IP for each country. Reduces rate limiting on multi-country runs. Only works when proxy is configured below.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Recommended for runs with many keywords or countries. Without proxy, Google may rate-limit after ~10-15 rapid requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
