# Rome2Rio Scraper | Multi-Modal Travel Routes (`parseforge/rome2rio-scraper`) Actor

Get travel routes between any two cities from Rome2Rio with flight, train, bus, ferry, and car options including duration, price, frequency, operators, and segment details. Power travel apps, itinerary tools, ground transport research, and transit data pipelines worldwide.

- **URL**: https://apify.com/parseforge/rome2rio-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, Real estate, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ✈️ Rome2Rio Scraper

> 🚀 **Export travel routes and prices between any two cities in seconds.** Train, bus, plane, rideshare, car ferry - every option Rome2Rio knows about, delivered to your dataset.

> 🕒 **Last updated:** 2026-05-21 - **📊 12 fields** per record - **11+ routes per query** - **Worldwide coverage**

The Rome2Rio Scraper extracts multi-modal travel route data directly from [rome2rio.com](https://www.rome2rio.com), one of the world's most comprehensive trip-planning platforms. Enter any origin and destination - cities, airports, train stations, or regions - and get a full breakdown of every transport option: train, bus, plane, rideshare, car, ferry, and hybrid combinations.

**Dataset provenance:** All data is scraped in real-time from Rome2Rio's publicly accessible search results pages. No login required. Prices are sourced from Rome2Rio's live aggregation of transport providers and may vary by date.

Rome2Rio covers routes across 6 continents, aggregating data from thousands of operators. The scraper captures route names, transport modes, journey durations, price ranges, transfer counts, and operator names - everything you need to compare travel options programmatically.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Travel technology companies | Building flight/train comparison tools |
| Tourism research analysts | Mapping transport accessibility worldwide |
| Logistics and mobility startups | Identifying viable routes between cities |
| Academic researchers | Studying global travel patterns and costs |
| Travel bloggers and journalists | Fact-checking route options and prices |
| Price monitoring services | Tracking transport cost trends over time |

### 📋 What the Rome2Rio Scraper does

- Queries Rome2Rio for all available transport options between two cities
- Extracts route name, transport mode, duration, price range, and transfer count
- Parses operator names where displayed (e.g. "Eurostar" for London-Paris train)
- Captures route detail URLs for further investigation
- Works with city names, airport codes, and place names recognized by Rome2Rio
- Supports any origin-destination pair worldwide

> 💡 **Why it matters:** Rome2Rio aggregates data from thousands of transport operators that have no public API. This scraper unlocks that dataset for research, comparison tools, and travel tech products without requiring manual queries.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `origin` | string | Yes | Starting city or location (e.g. "London", "New York", "Tokyo") |
| `destination` | string | Yes | Destination city or location (e.g. "Paris", "Los Angeles", "Osaka") |
| `maxItems` | number | No | Max routes to return. Free users: capped at 10. Paid: up to 1,000,000 |

**Example 1 - European city pair:**
```json
{
    "origin": "London",
    "destination": "Paris",
    "maxItems": 10
}
````

**Example 2 - Cross-continental route:**

```json
{
    "origin": "New York",
    "destination": "Los Angeles",
    "maxItems": 20
}
```

> ⚠️ **Good to Know:** Use the city names as you would type them in Rome2Rio's search box. The scraper passes your input directly to Rome2Rio, so "NYC", "New York City", or "New York" all work. If a city pair has no results, an error record is returned explaining why.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string/null | Transport mode icon URL (null - SVGs are inline) |
| 📌 `routeName` | string | Full route name (e.g. "Train (Eurostar)", "Fly London Heathrow Airport to Paris Charles De Gaulle Airport") |
| 🚆 `transportMode` | string | Primary mode (Train, Bus, Plane, Car, Rideshare, Carferry) |
| 🔗 `url` | string | Rome2Rio route detail page URL |
| ⏱ `duration` | string | Total journey time (e.g. "2h 28m", "9h 30m") |
| 💰 `priceFrom` | number/null | Minimum price in USD |
| 💰 `priceTo` | number/null | Maximum price in USD |
| 💵 `priceRange` | string/null | Human-readable range (e.g. "$170-290") |
| 🔄 `transfers` | number | Number of transfers/legs in the journey |
| 📏 `distance` | string/null | Journey distance in km (shown for some routes) |
| 🏢 `operator` | string/null | Transport operator (e.g. "Eurostar", "Flixbus") |
| 🕒 `scrapedAt` | string | ISO timestamp of when data was scraped |
| ❌ `error` | string/null | Error message if route could not be scraped |

**Sample records (London to Paris):**

```json
[
  {
    "imageUrl": null,
    "routeName": "Train (Eurostar)",
    "transportMode": "Train",
    "url": "https://www.rome2rio.com/map/London/Paris?route=Train",
    "duration": "2h 28m",
    "priceFrom": 170,
    "priceTo": 290,
    "priceRange": "$170-290",
    "transfers": 0,
    "distance": null,
    "operator": "Eurostar",
    "scrapedAt": "2026-05-22T01:09:23.174Z",
    "error": null
  },
  {
    "imageUrl": null,
    "routeName": "Rideshare",
    "transportMode": "Rideshare",
    "url": "https://www.rome2rio.com/map/London/Paris?route=Rideshare",
    "duration": "5h 49m",
    "priceFrom": 30,
    "priceTo": 65,
    "priceRange": "$30-65",
    "transfers": 0,
    "distance": null,
    "operator": null,
    "scrapedAt": "2026-05-22T01:09:23.174Z",
    "error": null
  },
  {
    "imageUrl": null,
    "routeName": "Bus",
    "transportMode": "Bus",
    "url": "https://www.rome2rio.com/map/London/Paris?route=Bus",
    "duration": "9h 30m",
    "priceFrom": 35,
    "priceTo": 75,
    "priceRange": "$35-75",
    "transfers": 0,
    "distance": null,
    "operator": null,
    "scrapedAt": "2026-05-22T01:09:23.174Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- **Real-time data** - Every run fetches live data directly from Rome2Rio, no cache
- **Multi-modal coverage** - Captures all transport types in one query: train, bus, plane, rideshare, car, ferry
- **Structured output** - Clean JSON with numeric price fields ready for analysis
- **Anti-detection built in** - Uses Camoufox stealth browser with residential proxies for reliable access
- **Worldwide routes** - Works for any city pair globally that Rome2Rio covers
- **Handles complex routes** - Captures multi-leg journeys (train + plane, drive + ferry)

### 📈 How it compares to alternatives

| Feature | This Actor | Manual search | Rome2Rio API (unofficial) |
|---|---|---|---|
| Setup time | 2 minutes | N/A | Hours of reverse engineering |
| Structured output | JSON, CSV, Excel | Manual copy | Raw HTML parsing required |
| Multi-modal | Yes (all modes) | Yes | Unreliable |
| Bulk queries | Yes | Tedious | Unknown rate limits |
| Proxy support | Residential (US) | N/A | N/A |
| Maintenance | Managed by ParseForge | N/A | None |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Go to the Rome2Rio Scraper actor page
3. Enter your **origin** and **destination** cities
4. Set **Max Items** (default: 10 for free, up to 1,000,000 for paid)
5. Click **Start** and download your dataset as JSON, CSV, or Excel

### 💼 Business use cases

#### 1. Travel comparison platforms

Build a route comparison tool that pulls real-time Rome2Rio data. Show users every way to get from A to B - train, bus, plane, rideshare - with current prices and durations, without scraping dozens of individual transport websites.

#### 2. Tourism and accessibility research

Map the transport connectivity between any two points on earth. Use the price and duration data to quantify how accessible destinations are by different income levels or time constraints. Ideal for academic research and government tourism planning.

#### 3. Corporate travel policy analysis

Query routes for your company's most frequent city pairs. Identify patterns - is the budget airline significantly slower than the train? Is rideshare actually cheaper for short routes? Back your travel policy decisions with real data.

#### 4. Travel content creation

Verify route facts for travel articles, destination guides, and comparison posts. Get accurate duration and price ranges for any route pair without manual research.

### 🔌 Automating Rome2Rio Scraper

Connect this actor to your workflows using Apify's built-in integrations:

- **Make (Integromat):** Trigger on a schedule, send results to Google Sheets or Airtable
- **Zapier:** Connect to 5,000+ apps - auto-send route data to Slack, Notion, or email
- **n8n:** Build custom automation workflows with the Apify node
- **Apify API:** Call the actor from any language via REST API
- **Webhooks:** Receive dataset URLs via webhook when each run completes

### 🌟 Beyond business use cases

#### 🔬 Academic research

Study global transport infrastructure development. Compare route options across different regions to understand mobility inequality and the evolution of transport networks.

#### 🎨 Creative projects

Build interactive travel visualization tools. Power data art projects showing the web of transport connections between world cities.

#### 🌍 Non-profit and development work

Identify underserved routes where transport options are limited or expensive. Support advocacy for better transport infrastructure in developing regions.

#### 🧪 Experimentation

Test travel hypotheses: How does transport mode availability correlate with city size? Which modes dominate for sub-500km routes vs. long-haul? Explore with real data.

### 🤖 Ask an AI assistant about this scraper

You can paste this page's URL into ChatGPT, Claude, or Gemini and ask:

- "What fields does this scraper return and how can I use the price data?"
- "Write a Python script to filter these results by transportMode = 'Train'"
- "How would I use this data to build a route comparison feature?"

### ❓ Frequently Asked Questions

**🔍 What cities can I use as origin and destination?**
Any city, region, airport, or location that Rome2Rio recognizes. If Rome2Rio shows routes for it, the scraper will return them.

**💵 Are prices in USD?**
Yes, prices are shown in USD as Rome2Rio's default currency for unlocalized requests.

**📊 How many routes does it return per query?**
Typically 6-12 routes per city pair, depending on how many transport options Rome2Rio has indexed.

**🔄 How often can I run it?**
As often as you need. Each run fetches fresh data in real-time.

**🌐 Does it work for routes outside Europe?**
Yes, Rome2Rio has global coverage. Routes in the Americas, Asia, Africa, and Oceania are all supported.

**💸 Why are some priceFrom/priceTo fields null?**
Some route types (like driving via Eurotunnel) show no price estimate on Rome2Rio's listing page.

**⏱ How long does a run take?**
Typically 10-30 seconds per query including browser startup time.

**📏 Is the distance field always populated?**
No. Distance appears conditionally - Rome2Rio shows it for some routes (especially rideshare) but not others.

**🏢 Is the operator field always populated?**
Only when Rome2Rio displays an operator name in parentheses next to the route name (e.g. "Train (Eurostar)").

**🔒 Do I need a Rome2Rio account?**
No. The scraper uses publicly accessible search results that require no login.

**🤖 Will the scraper break if Rome2Rio updates their site?**
We monitor and update the scraper for any site changes. Updates are deployed automatically.

**📅 Can I scrape routes for specific dates?**
Rome2Rio's search results page does not support date filtering - it shows general route options and price ranges. For date-specific pricing, you'd need to follow individual booking links.

### 🔌 Integrate with any app

Export your dataset in any format and connect to your stack:

- **Google Sheets** - via Make or Zapier
- **Airtable** - via Make or Zapier
- **Notion** - via n8n or Zapier
- **Slack** - send route summaries automatically
- **PostgreSQL / MySQL** - via Apify API and your ETL tool
- **BigQuery** - connect via Apify's Google Cloud integrations
- **Power BI / Tableau** - import CSV/Excel exports
- **REST API** - poll the Apify dataset API directly in JSON

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Scrape global airport data including IATA codes, coordinates, and types |
| [Hostelworld Scraper](https://apify.com/parseforge/hostelworld-scraper) | Extract hostel listings, prices, and ratings from Hostelworld |
| [Numbeo Scraper](https://apify.com/parseforge/numbeo-scraper) | Pull cost-of-living data for cities worldwide |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ production-ready scrapers covering travel, finance, jobs, and more.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or connected to Rome2Rio in any way. It collects only publicly available data accessible to any web browser without authentication. Use in accordance with Rome2Rio's terms of service and applicable laws.

# Actor input Schema

## `origin` (type: `string`):

Starting city or location (e.g. London, New York, Tokyo)

## `destination` (type: `string`):

Destination city or location (e.g. Paris, Los Angeles, Osaka)

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "origin": "London",
  "destination": "Paris",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "origin": "London",
    "destination": "Paris",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rome2rio-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 = {
    "origin": "London",
    "destination": "Paris",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rome2rio-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 '{
  "origin": "London",
  "destination": "Paris",
  "maxItems": 10
}' |
apify call parseforge/rome2rio-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rome2Rio Scraper | Multi-Modal Travel Routes",
        "description": "Get travel routes between any two cities from Rome2Rio with flight, train, bus, ferry, and car options including duration, price, frequency, operators, and segment details. Power travel apps, itinerary tools, ground transport research, and transit data pipelines worldwide.",
        "version": "0.1",
        "x-build-id": "bi7BKNtoRnm3n0f9x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rome2rio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rome2rio-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/parseforge~rome2rio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rome2rio-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/parseforge~rome2rio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rome2rio-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": [
                    "origin",
                    "destination"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin",
                        "type": "string",
                        "description": "Starting city or location (e.g. London, New York, Tokyo)"
                    },
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "Destination city or location (e.g. Paris, Los Angeles, Osaka)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
