# Waze Traffic Scraper (`burbn/waze-traffic-scraper`) Actor

Get live traffic alerts, road hazards, police reports, closures & jams directly from Waze without official API keys! 🚨 Search any location worldwide using a simple bounding box or radius. Ideal for route planning, fleet management, and real-time logistics mapping.

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

## Pricing

from $5.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Waze Traffic Scraper | Real-Time Traffic Alerts & Jams API

Scrape real-time traffic alerts and jams from Waze by geographic area. Get accidents, hazards, road blocks, police reports, and traffic jam data with location, severity, reliability, and confidence scores. The best Waze traffic data scraper for route planning, traffic monitoring, and fleet management.

### ❓ What is Waze Traffic Scraper?

**Waze Traffic Scraper** is a powerful Apify actor that lets you scrape real-time traffic data from Waze for any geographic area in the world. Whether you're monitoring traffic conditions, planning routes, or analyzing traffic patterns — this actor gives you structured, exportable data from the world's largest community-driven navigation app.

With this Waze Traffic Scraper actor, you can:

- 🚨 **Get real-time alerts** — Accidents, hazards, road blocks, police reports, and more
- 🚧 **Get traffic jams** — Real-time traffic jam data with severity and location
- 📍 **Search by bounding box** — Define a rectangular geographic area with bottom-left and top-right coordinates
- 📍 **Search by center + radius** — Define a circular area with center point and radius (KM or MI)
- 🎛️ **Filter by alert type** — Only get specific alert types like HAZARD, ACCIDENT, POLICE
- 📊 **Export structured data** — Download results in JSON, CSV, Excel, XML, and RSS formats

### 🎯 What Data Can You Extract?

This Waze Traffic Scraper actor extracts the following data for each alert and jam:

| Field | Description |
|-------|-------------|
| `alert_id` | Unique identifier for the alert |
| `type` | Alert type (HAZARD, ACCIDENT, POLICE, etc.) |
| `subtype` | Alert subtype for more detail |
| `reported_by` | Who reported the alert |
| `description` | Human-readable description of the alert |
| `image` | Image URL if available |
| `publish_datetime_utc` | When the alert was published (UTC) |
| `country` | Country code |
| `city` | City name |
| `street` | Street name |
| `latitude` | GPS latitude |
| `longitude` | GPS longitude |
| `num_thumbs_up` | Number of thumbs up from Waze users |
| `alert_reliability` | Reliability score of the alert |
| `alert_confidence` | Confidence score of the alert |
| `near_by` | Nearby location description |
| `comments` | User comments on the alert |
| `num_comments` | Number of comments |
| `data_type` | Whether this record is an "alert" or "jam" |

### 🚨 Supported Alert Types

| Type | Description |
|------|-------------|
| 🚗 ACCIDENT | Traffic accidents |
| ⚠️ HAZARD | Road hazards (objects, potholes, etc.) |
| 🚧 ROAD_CLOSED | Road blocks and closures |
| 🚔 POLICE | Police presence |
| 🚧 JAM | Traffic jams and congestion |
| 🏗️ CONSTRUCTION | Road construction |

### 🚀 How to Use Waze Traffic Scraper

#### Step 1: Define the Search Area

Choose one of two methods:

**Option A: Bounding Box** — Specify bottom-left and top-right corners of a rectangle:
- `bottom_left`: `"51.400,-0.300"`
- `top_right`: `"51.600,0.100"`

**Option B: Center + Radius** — Specify a center point and radius:
- `center`: `"51.5074,-0.1278"`
- `radius`: `"5"`
- `radius_units`: `"KM"` or `"MI"`

#### Step 2: Configure Filters (Optional)

| Input | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `bottom_left` | String | Conditional | `51.400,-0.300` | Bottom-left lat,lng (required if no center) |
| `top_right` | String | Conditional | `51.600,0.100` | Top-right lat,lng (required if no center) |
| `center` | String | Conditional | — | Center lat,lng (required if no bbox) |
| `radius` | String | Conditional | — | Radius from center |
| `radius_units` | String | ❌ No | `KM` | `KM` or `MI` |
| `max_alerts` | Integer | ❌ No | `20` | Max alerts to fetch (0 = skip) |
| `max_jams` | Integer | ❌ No | `20` | Max jams to fetch (0 = skip) |
| `alert_types` | Array | ❌ No | `[]` | Select one or more types: `["HAZARD", "ACCIDENT", "POLICE"]` |
| `alert_subtypes` | String | ❌ No | — | Comma-separated alert subtypes |

#### Step 3: Run and Download Results

Click **Start** to run the Waze Traffic Scraper. Results are available in JSON, CSV, Excel, XML, and RSS formats.

### 📋 Example Input (Bounding Box)

```json
{
  "bottom_left": "51.400,-0.300",
  "top_right": "51.600,0.100",
  "max_alerts": 20,
  "max_jams": 20
}
````

### 📋 Example Input (Center + Radius)

```json
{
  "center": "51.5074,-0.1278",
  "radius": "10",
  "radius_units": "KM",
  "max_alerts": 50,
  "max_jams": 50
}
```

### 📋 Example Output

```json
{
  "alert_id": "160673696",
  "type": "HAZARD",
  "subtype": null,
  "reported_by": "London Transport",
  "description": "OCCUPANCY OF ROADWAY AS STIPULATED",
  "image": null,
  "publish_datetime_utc": "2025-02-14T05:00:00.000Z",
  "country": "GB",
  "city": "London",
  "street": "Piccadilly",
  "latitude": 51.5074,
  "longitude": -0.1278,
  "num_thumbs_up": 3,
  "alert_reliability": 9,
  "alert_confidence": 1,
  "near_by": null,
  "comments": [],
  "num_comments": 0,
  "data_type": "alert",
  "search_bottom_left": "51.400,-0.300",
  "search_top_right": "51.600,0.100"
}
```

### 🎨 Dataset Views

The Waze Traffic Scraper actor provides 2 organized dataset views for easy analysis:

| View | Description |
|------|-------------|
| 🚨 **Alerts & Jams Overview** | Type, subtype, city, street, description, and coordinates for quick scanning |
| 📋 **Full Details** | Complete data with reliability, confidence, comments, images, and search parameters |

### 💡 Use Cases for Waze Traffic Scraper

- **Traffic Monitoring** — Monitor real-time traffic conditions in any area
- **Route Planning** — Check road conditions before planning a route
- **Fleet Management** — Track traffic alerts along fleet routes
- **Smart City Analytics** — Analyze traffic patterns and incident hotspots
- **News & Journalism** — Get real-time accident and incident data for reporting
- **Insurance Analytics** — Analyze accident frequency and patterns by area
- **Urban Planning** — Study traffic flow and congestion patterns
- **Emergency Response** — Monitor road closures and hazard reports
- **Transportation Research** — Collect traffic data for academic studies
- **Logistics Optimization** — Avoid jams and road closures for delivery routes

### 🔧 Tips for Best Results

1. **Start with a small area** — Begin with a neighborhood-sized bounding box and expand as needed
2. **Use center + radius for circular areas** — Ideal for monitoring around a specific point
3. **Set max\_alerts and max\_jams** — Control how much data you get per request
4. **Filter by alert type** — Use `alert_types` to only get relevant data (e.g., only accidents)
5. **Export in your preferred format** — Download traffic data in JSON, CSV, or Excel

### 🏷️ Tags

`waze` `traffic` `traffic alerts` `traffic jams` `waze scraper` `waze traffic` `waze alerts` `traffic data` `road conditions` `accidents` `hazards` `police reports` `road blocks` `traffic monitoring` `fleet management` `route planning` `smart city` `traffic api` `waze api` `real-time traffic` `traffic scraper` `road closures` `traffic analysis` `transportation data`

### 🎁 Get $5 Free Apify Credits

New to Apify? [Sign up using this link](https://apify.com?fpr=free-credits) and get **$5 free credits** to start scraping Waze traffic data right away! No credit card required.

### 📞 Support

For questions, feedback, or issues with this Waze Traffic Scraper actor, please contact us through Apify or open an issue.

***

**Happy scraping! 🚗✨**

# Actor input Schema

## `bottom_left` (type: `string`):

Bottom-left corner of the geographic rectangular area. Specified as latitude, longitude pair (e.g., "51.400,-0.300"). Required if center and radius are not specified.

## `top_right` (type: `string`):

Top-right corner of the geographic rectangular area. Specified as latitude, longitude pair (e.g., "51.600,0.100"). Required if center and radius are not specified.

## `center` (type: `string`):

Center point of the search area as latitude, longitude pair (e.g., "51.5074,-0.1278"). Use this with radius instead of bounding box. Required if bottom\_left and top\_right are not specified.

## `radius` (type: `string`):

Radius of the search area from the center point. Required if center is specified.

## `radius_units` (type: `string`):

Unit of measurement for the radius.

## `max_alerts` (type: `integer`):

Maximum number of alerts to fetch. Set to 0 to skip fetching alerts entirely.

## `max_jams` (type: `integer`):

Maximum number of traffic jams to fetch. Set to 0 to skip fetching jams entirely.

## `alert_types` (type: `array`):

Only return alerts of specific types. Select one or more alert types to filter results.

## `alert_subtypes` (type: `array`):

Only return alerts of specific subtypes. Select one or more alert subtypes to filter results.

## Actor input object example

```json
{
  "bottom_left": "51.400,-0.300",
  "top_right": "51.600,0.100",
  "radius_units": "KM",
  "max_alerts": 20,
  "max_jams": 20,
  "alert_types": [],
  "alert_subtypes": []
}
```

# Actor output Schema

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

View all found traffic alerts and jams with type, location, and description info.

## `details` (type: `string`):

View complete results with all metadata including reliability, confidence, comments, and search parameters.

# 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 = {
    "bottom_left": "51.400,-0.300",
    "top_right": "51.600,0.100",
    "max_alerts": 20,
    "max_jams": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("burbn/waze-traffic-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 = {
    "bottom_left": "51.400,-0.300",
    "top_right": "51.600,0.100",
    "max_alerts": 20,
    "max_jams": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("burbn/waze-traffic-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 '{
  "bottom_left": "51.400,-0.300",
  "top_right": "51.600,0.100",
  "max_alerts": 20,
  "max_jams": 20
}' |
apify call burbn/waze-traffic-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Waze Traffic Scraper",
        "description": "Get live traffic alerts, road hazards, police reports, closures & jams directly from Waze without official API keys! 🚨 Search any location worldwide using a simple bounding box or radius. Ideal for route planning, fleet management, and real-time logistics mapping.",
        "version": "1.0",
        "x-build-id": "Xde2wtlVrMYYWJgbK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/burbn~waze-traffic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-burbn-waze-traffic-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/burbn~waze-traffic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-burbn-waze-traffic-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/burbn~waze-traffic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-burbn-waze-traffic-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": [
                    "bottom_left",
                    "top_right"
                ],
                "properties": {
                    "bottom_left": {
                        "title": "📍 Bottom-Left Corner (lat, lng)",
                        "type": "string",
                        "description": "Bottom-left corner of the geographic rectangular area. Specified as latitude, longitude pair (e.g., \"51.400,-0.300\"). Required if center and radius are not specified.",
                        "default": "51.400,-0.300"
                    },
                    "top_right": {
                        "title": "📍 Top-Right Corner (lat, lng)",
                        "type": "string",
                        "description": "Top-right corner of the geographic rectangular area. Specified as latitude, longitude pair (e.g., \"51.600,0.100\"). Required if center and radius are not specified.",
                        "default": "51.600,0.100"
                    },
                    "center": {
                        "title": "📍 Center Point (lat, lng)",
                        "type": "string",
                        "description": "Center point of the search area as latitude, longitude pair (e.g., \"51.5074,-0.1278\"). Use this with radius instead of bounding box. Required if bottom_left and top_right are not specified."
                    },
                    "radius": {
                        "title": "📏 Radius",
                        "type": "string",
                        "description": "Radius of the search area from the center point. Required if center is specified."
                    },
                    "radius_units": {
                        "title": "📏 Radius Units",
                        "enum": [
                            "KM",
                            "MI"
                        ],
                        "type": "string",
                        "description": "Unit of measurement for the radius.",
                        "default": "KM"
                    },
                    "max_alerts": {
                        "title": "🚨 Max Alerts",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of alerts to fetch. Set to 0 to skip fetching alerts entirely.",
                        "default": 20
                    },
                    "max_jams": {
                        "title": "🚧 Max Jams",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of traffic jams to fetch. Set to 0 to skip fetching jams entirely.",
                        "default": 20
                    },
                    "alert_types": {
                        "title": "🏷️ Alert Types Filter",
                        "type": "array",
                        "description": "Only return alerts of specific types. Select one or more alert types to filter results.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "HAZARD",
                                "ACCIDENT",
                                "POLICE",
                                "ROAD_CLOSED",
                                "JAM",
                                "WEATHERHAZARD",
                                "MISC"
                            ],
                            "enumTitles": [
                                "⚠️ Hazard",
                                "🚗 Accident",
                                "👮 Police",
                                "🚧 Road Closed",
                                "🚦 Jam",
                                "🌧️ Weather Hazard",
                                "📌 Miscellaneous"
                            ]
                        },
                        "default": []
                    },
                    "alert_subtypes": {
                        "title": "🏷️ Alert Subtypes Filter",
                        "type": "array",
                        "description": "Only return alerts of specific subtypes. Select one or more alert subtypes to filter results.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "HAZARD_ON_ROAD_CONSTRUCTION",
                                "HAZARD_ON_ROAD_OBSTACLE",
                                "HAZARD_ON_ROAD_TURTLE",
                                "HAZARD_ON_ROAD_ANIMAL",
                                "HAZARD_ON_ROAD_CAR_STOPPED",
                                "HAZARD_ON_ROAD_CAR_PART",
                                "HAZARD_ON_ROAD_OTHER",
                                "POLICE_HIDING",
                                "POLICE_STOPPING_CAR",
                                "ROAD_CLOSED_EVENT",
                                "ROAD_CLOSED_CONSTRUCTION",
                                "ROAD_CLOSED_OTHER"
                            ],
                            "enumTitles": [
                                "Construction Obstruction",
                                "General Obstruction",
                                "Turtle",
                                "Animal",
                                "Car Stopped",
                                "Car Part on Road",
                                "Other Hazard",
                                "Police Hiding",
                                "Police Stopping Car",
                                "Road Closed (Event)",
                                "Road Closed (Construction)",
                                "Other Road Closure"
                            ]
                        },
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
