# Ryanair Scraper (`maximedupre/ryanair-scraper`) Actor

Scrape Ryanair fares by route, date, flexible date window, passenger mix, price, and sort order. Export prices, flight numbers, local times, duration, airport details, booking links, and scrape timestamps.

- **URL**: https://apify.com/maximedupre/ryanair-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.25 / 1,000 fare options

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### ✈️ Ryanair scraper API for fares and flight data

Ryanair Scraper collects public fare data from [Ryanair](https://www.ryanair.com/) by route, travel date, flexible date window, passenger mix, maximum price, and sort order. Enter origin and destination airport IATA codes, pick a departure date, and the Actor saves clean Ryanair fare rows with prices, passenger fare breakdowns, flight numbers, local times, duration, airport details, booking links, and scrape timestamps.

Use this Ryanair scraper when you need repeatable route fare checks without opening Ryanair pages by hand. It is useful for travel dashboards, fare monitoring, route research, price comparison workflows, OTA checks, and internal travel tools that need structured Ryanair flight data through Apify exports, API access, schedules, webhooks, or integrations.

For a quick first run, keep the prefilled `STN` to `DUB` route, keep the prefilled date, and leave **Maximum fare rows** at `25`. Once the output shape matches your workflow, change the route, add a return date, adjust the flexible date window, raise the limit, schedule repeat runs, or call the Actor through the Apify API.

### 🔎 What this Actor does

- Searches public Ryanair fare data for one-way and round-trip route inputs.
- Accepts three-letter IATA airport codes for origin and destination airports.
- Uses `departureDate` as the outbound travel date.
- Uses optional `returnDate` to run the reverse route as the inbound leg.
- Supports adult, teen, child, and infant passenger counts.
- Supports a flexible date window around each submitted travel date.
- Can filter saved fares by maximum price in the source currency.
- Saves one dataset item per accepted Ryanair fare option.
- Returns prices, currency, passenger fare breakdowns, flight numbers, carrier, local departure and arrival times, duration, airport details, availability hints, route links, booking links, and scrape timestamps.
- Can sort saved rows by source order, cheapest, earliest departure, or shortest duration.
- Works with Apify dataset exports, API clients, schedules, webhooks, and integrations.

The Actor focuses on public Ryanair fare options returned for the submitted route and date window. It does not compare other airlines, book flights, hold fares, log in to Ryanair accounts, redeem vouchers, scrape seat maps, or guarantee that a fare remains available after the run.

### 📦 Data you can extract

Each dataset item is one Ryanair fare option. Fields can be empty when Ryanair does not show that value for the fare.

- `type` - `ryanair_fare`
- `rank` - result position after filtering and sorting
- `source` - `Ryanair`
- `tripType`, `legDirection`, `departureDate`, and `returnDate`
- `price` - total fare, source currency, and passenger-level fare breakdown
- `currency`
- `flightNumber`, `carrierCode`, and `carrierName`
- `departureAirport` and `arrivalAirport` - airport code, name, city, country, and country code when available
- `localDepartureTime`, `localArrivalTime`, `duration`, and `durationMinutes`
- `passengers` - adult, teen, child, infant, and total passenger counts
- `availability` - fares-left and availability status when returned by the source
- `fare` - fare class when returned by the source
- `links` - Ryanair route and booking URLs
- `sourceMetadata` and `scrapedAt`

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or read the same rows from the Apify API.

### 🚀 How to run it

1. Open the Input tab.
2. Enter an origin airport IATA code, such as `BVA` or `STN`.
3. Enter a destination airport IATA code, such as `BHX` or `DUB`.
4. Pick the outbound departure date.
5. Add a return date only when you want round-trip leg rows.
6. Set adult, teen, child, and infant passenger counts.
7. Optional: set a flexible date window, maximum price, sort order, and maximum fare rows.
8. Run the Actor and open the dataset.

### ⚙️ Input options

`Origin airport` and `Destination airport` are three-letter IATA airport codes. The Actor normalizes them to uppercase and stops cleanly when both airports are the same.

`Departure date` is the outbound travel date to search. `Return date` is optional. When you add it, the Actor searches the reverse route as an inbound leg and returns those rows with `legDirection: "inbound"`.

`Flexible date window` sets how many days around each travel date to include. Use `0` for the exact date only, or raise it when you want nearby fare options.

`Adults`, `Teens`, `Children`, and `Infants` set the passenger mix used for the fare search. The Actor stops cleanly before source traffic when the passenger mix is not accepted by the search rules, such as more infants than adults.

`Maximum fare price` keeps only fare rows at or below the submitted price in Ryanair's source currency.

`Sort fare rows by` controls result order before the limit is applied. Use `Cheapest` for price checks, `Earliest departure` for schedule checks, `Shortest duration` for quick trips, or `Source order` to keep Ryanair's order.

`Maximum fare rows` caps how many fare rows are saved and charged. Use a small limit for a quick first run.

### 🧾 Example input

```json
{
	"originAirport": "STN",
	"destinationAirport": "DUB",
	"departureDate": "2026-07-15",
	"flexDays": 3,
	"adults": 1,
	"teens": 0,
	"children": 0,
	"infants": 0,
	"sortBy": "cheapest",
	"maxResults": 25
}
````

### 📊 Example output

```json
{
	"type": "ryanair_fare",
	"rank": 1,
	"source": "Ryanair",
	"tripType": "oneWay",
	"legDirection": "outbound",
	"departureDate": "2026-07-15",
	"returnDate": null,
	"price": {
		"total": 19.99,
		"currency": "GBP",
		"passengers": [
			{
				"type": "ADT",
				"count": 1,
				"amount": 19.99,
				"total": 19.99
			}
		]
	},
	"currency": "GBP",
	"flightNumber": "FR256",
	"carrierCode": "FR",
	"carrierName": "Ryanair",
	"departureAirport": {
		"code": "STN",
		"name": "London (Stansted)",
		"city": "London (Stansted)",
		"country": null,
		"countryCode": null
	},
	"arrivalAirport": {
		"code": "DUB",
		"name": "Dublin",
		"city": "Dublin",
		"country": null,
		"countryCode": null
	},
	"localDepartureTime": "22:45",
	"localArrivalTime": "00:05",
	"duration": "1 hr 20 min",
	"durationMinutes": 80,
	"passengers": {
		"adults": 1,
		"teens": 0,
		"children": 0,
		"infants": 0,
		"total": 1
	},
	"availability": {
		"faresLeft": 3,
		"status": "available"
	},
	"fare": {
		"fareClass": null
	},
	"links": {
		"route": "https://www.ryanair.com/gb/en/trip/flights/select?...",
		"booking": "https://www.ryanair.com/gb/en/trip/flights/select?..."
	},
	"sourceMetadata": {
		"sourceCurrency": "GBP",
		"sourceFetchedAt": "2026-06-11T14:53:09.122Z"
	},
	"scrapedAt": "2026-06-11T14:53:11.878Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged once for each accepted Ryanair fare option saved to the dataset.

Set **Maximum fare rows** to control the upper bound for one run. Runs with no matching fares complete successfully and do not save placeholder rows.

### ⚠️ Limits and caveats

- Prices and availability can change after the run. Use the booking link to verify the fare before acting on it.
- Currency is returned from Ryanair's source response. The Actor does not convert prices.
- Round-trip searches return outbound and inbound leg rows, not paired booking itineraries.
- No-flight routes, sold-out dates, and unavailable source responses can produce zero rows.
- The Actor does not require Ryanair credentials, cookies, or user-provided proxy settings.

### ❓ FAQ

#### 🔌 Can I use this as a Ryanair API?

Yes. Run the Actor from Apify Console, call it through the Apify API, schedule recurring runs, or connect results to webhooks and integrations. The output is saved as structured dataset rows.

#### 🔁 Does it support round trips?

Yes. Add `returnDate` and the Actor searches the reverse route as the inbound leg. Output rows use `legDirection` so you can separate outbound and inbound fares.

#### 📅 Can I search flexible Ryanair fares?

Yes. Set `flexDays` to include dates around the submitted departure date and return date. Use `0` when you only want the exact travel date.

#### 🎟️ Does it book flights?

No. It extracts public Ryanair fare data and includes Ryanair links for follow-up. It does not reserve, hold, or buy tickets.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~ryanair-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Flight Scraper ↗](https://apify.com/maximedupre/flight-scraper) - Compare public itinerary prices, airlines, times, stops, duration, and booking links from multiple flight sources.
- [EasyJet Scraper ↗](https://apify.com/maximedupre/easyjet-scraper) - Extract EasyJet route fares, flight numbers, local times, duration, airport details, and booking links.
- [Award Flights Scraper ↗](https://apify.com/maximedupre/award-flights-scraper) - Search award flight availability by route, date window, cabin, and loyalty program.
- [Realtor Scraper ↗](https://apify.com/maximedupre/realtor-scraper) - Scrape Realtor.com property listings with prices, addresses, photos, agents, and property details.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find public business addresses from company websites and keep source evidence for each row.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `originAirport` (type: `string`):

Three-letter IATA airport code to depart from, such as STN.

## `destinationAirport` (type: `string`):

Three-letter IATA airport code to arrive at, such as DUB.

## `departureDate` (type: `string`):

Outbound travel date to search first.

## `returnDate` (type: `string`):

Return travel date for round-trip fare searches.

## `flexDays` (type: `integer`):

Number of days around each travel date to include.

## `adults` (type: `integer`):

Number of adult passengers.

## `teens` (type: `integer`):

Number of teen passengers.

## `children` (type: `integer`):

Number of child passengers.

## `infants` (type: `integer`):

Number of infant passengers.

## `maxPrice` (type: `number`):

Highest fare price to keep in the source currency.

## `sortBy` (type: `string`):

Choose which matching fare options appear first.

## `maxResults` (type: `integer`):

Maximum Ryanair fare rows to save.

## Actor input object example

```json
{
  "originAirport": "STN",
  "destinationAirport": "DUB",
  "departureDate": "2026-07-15",
  "flexDays": 3,
  "adults": 1,
  "teens": 0,
  "children": 0,
  "infants": 0,
  "sortBy": "cheapest",
  "maxResults": 25
}
```

# Actor output Schema

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

Ryanair fare options saved in the default dataset.

## `csv` (type: `string`):

Ryanair fare options formatted as CSV for spreadsheets.

# 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 = {
    "originAirport": "STN",
    "destinationAirport": "DUB",
    "departureDate": "2026-07-15",
    "flexDays": 3,
    "adults": 1,
    "teens": 0,
    "children": 0,
    "infants": 0,
    "sortBy": "cheapest",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/ryanair-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 = {
    "originAirport": "STN",
    "destinationAirport": "DUB",
    "departureDate": "2026-07-15",
    "flexDays": 3,
    "adults": 1,
    "teens": 0,
    "children": 0,
    "infants": 0,
    "sortBy": "cheapest",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/ryanair-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 '{
  "originAirport": "STN",
  "destinationAirport": "DUB",
  "departureDate": "2026-07-15",
  "flexDays": 3,
  "adults": 1,
  "teens": 0,
  "children": 0,
  "infants": 0,
  "sortBy": "cheapest",
  "maxResults": 25
}' |
apify call maximedupre/ryanair-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ryanair Scraper",
        "description": "Scrape Ryanair fares by route, date, flexible date window, passenger mix, price, and sort order. Export prices, flight numbers, local times, duration, airport details, booking links, and scrape timestamps.",
        "version": "0.1",
        "x-build-id": "E0xrl8SpOMtIsGTfo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~ryanair-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-ryanair-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/maximedupre~ryanair-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-ryanair-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/maximedupre~ryanair-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-ryanair-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": [
                    "originAirport",
                    "destinationAirport",
                    "departureDate"
                ],
                "properties": {
                    "originAirport": {
                        "title": "Origin airport",
                        "pattern": "^[A-Za-z]{3}$",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "Three-letter IATA airport code to depart from, such as STN."
                    },
                    "destinationAirport": {
                        "title": "Destination airport",
                        "pattern": "^[A-Za-z]{3}$",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "Three-letter IATA airport code to arrive at, such as DUB."
                    },
                    "departureDate": {
                        "title": "Departure date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Outbound travel date to search first."
                    },
                    "returnDate": {
                        "title": "Return date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Return travel date for round-trip fare searches."
                    },
                    "flexDays": {
                        "title": "Flexible date window",
                        "minimum": 0,
                        "maximum": 7,
                        "type": "integer",
                        "description": "Number of days around each travel date to include.",
                        "default": 3
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers.",
                        "default": 1
                    },
                    "teens": {
                        "title": "Teens",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of teen passengers.",
                        "default": 0
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of child passengers.",
                        "default": 0
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of infant passengers.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum fare price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Highest fare price to keep in the source currency."
                    },
                    "sortBy": {
                        "title": "Sort fare rows by",
                        "enum": [
                            "sourceOrder",
                            "cheapest",
                            "earliestDeparture",
                            "shortestDuration"
                        ],
                        "type": "string",
                        "description": "Choose which matching fare options appear first.",
                        "default": "cheapest"
                    },
                    "maxResults": {
                        "title": "Maximum fare rows",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum Ryanair fare rows to save.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
