# Flight Scraper (`maximedupre/flight-scraper`) Actor

Flight scraper for public route searches. Compare itinerary prices, airlines, times, stops, duration, baggage hints, and booking links from multiple flight sources.

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

## Pricing

$2.25 / 1,000 flight itineraries

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

### ✈️ Flight scraper for public prices and schedules

Flight Scraper searches public flight sources by route and date, then saves clean itinerary rows you can export or use through the Apify API. Enter an origin, destination, departure date, passenger count, cabin, currency, and filters, and the Actor returns flight prices, airlines, departure and arrival times, stops, duration, baggage hints, source prices, booking links, and scrape timestamps.

Use this flight scraper when you need a repeatable way to compare fares without opening [Google Flights](https://www.google.com/travel/flights), Skyscanner, Kayak, Kiwi, Ryanair, or easyJet by hand. It is useful for airfare monitoring, travel dashboards, price comparison tools, OTA research, route checks, and internal travel workflows.

For a first run, keep the prefilled `LAX` to `JFK` route, keep the prefilled departure date, and leave `Flight result limit` at `100`. Once the output shape matches your workflow, lower the limit for quicker checks, add filters, schedule repeat runs, or call the Actor through the Apify API.

### 🔎 What this Actor does

- Searches public flight itinerary data for one-way and round-trip inputs.
- Accepts city names, airport names, and IATA airport codes.
- Compares merged prices from supported public sources when the same itinerary appears more than once.
- Saves one dataset item per accepted flight itinerary.
- Returns airlines, route, departure and arrival times, duration, stops, layovers, segments, baggage fields, source prices, and booking or source links.
- Supports filters for stops, maximum price, preferred airlines, excluded airlines, departure time, and arrival time.
- Supports sorting by balanced value, cheapest, fastest, or non-stop first.
- Works with Apify dataset exports, API clients, schedules, webhooks, and integrations.

The Actor focuses on public itinerary results for the submitted route and date. It does not book flights, hold fares, log in to airline accounts, redeem miles, or emit stale cached price-only rows when a source does not provide date-correct itinerary details.

### 📦 Data you can extract

Each dataset item is one public flight itinerary. Fields can be empty when a source does not show that detail for a flight.

- `rank` - 1-based result order after filters and sorting
- `prices` - lowest observed price by source for the itinerary
- `bestPrice`, `cheapestSource`, and `sourcesFound` - merged price summary
- `currency` - requested output currency
- `airline` - airline or airline group shown for the itinerary
- `from` and `to` - airport code and available airport details
- `departDate`, `departTime`, `arriveDate`, and `arriveTime`
- `duration`, `durationMinutes`, and `stops`
- `segments` - flight legs with airline, flight number, airports, times, duration, and cabin
- `layovers` - layover airport and duration details when available
- `baggage` - personal item, carry-on, and checked-bag allowance fields when public fare data is available
- `highlights` - cheapest, fastest, best, or multi-source recommendation flags
- `travelHack` and `isSelfTransfer` - self-transfer and virtual-interlining indicators when sources show them
- `links` - booking and source search links
- `scrapedAt` - UTC timestamp when the row was saved

### 🚀 How to run it

1. Open the Input tab.
2. Choose `One-way` or `Round-trip`.
3. Enter an origin such as `LAX`, `Los Angeles`, or `Los Angeles International`.
4. Enter a destination such as `JFK`, `New York`, or `John F. Kennedy International`.
5. Pick a departure date and optional return date.
6. Keep the default passenger count and currency, or adjust them for your search.
7. Add optional filters for stops, price, airlines, or time windows.
8. Run the Actor and open the dataset.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also consume the same rows through the Apify API, schedule recurring fare checks, or connect runs to webhooks and integrations.

### ⚙️ Input options

`Trip type` chooses one-way or round-trip search.

`Origin` and `Destination` accept city names, airport names, or IATA airport codes.

`Departure date` is the outbound flight date. `Return date` is optional and applies to round-trip searches.

`Passengers` sets the number of adult passengers to price. The public form accepts 1 to 9 passengers.

`Currency` is the ISO currency code used for prices, such as `USD`, `EUR`, `GBP`, `CAD`, or `AUD`.

`Cabin class` supports economy, premium economy, business, and first class.

`Stops`, `Maximum price`, `Preferred airlines`, `Excluded airlines`, `Earliest departure time`, `Latest departure time`, and `Arrive before` help narrow the saved itineraries.

`Sort flights by` controls result order before the limit is applied.

`Add baggage allowance` keeps baggage fields in the output when public fare data includes them.

`Flight result limit` caps how many itinerary rows are saved. Use a small limit for a quick first run.

### 🧾 Example input

```json
{
	"tripType": "oneWay",
	"origin": "LAX",
	"destination": "JFK",
	"departureDate": "2026-07-15",
	"maxResults": 100,
	"passengers": 1,
	"currency": "USD",
	"sortBy": "balanced",
	"cabinClass": "economy",
	"maxStops": "any",
	"includeBaggageEstimate": true
}
````

### 📄 Example output

```json
{
	"type": "flight_itinerary",
	"rank": 1,
	"prices": {
		"skyscanner": 205.4,
		"kayak": 205.4,
		"priceline": 205.4,
		"expedia": 205.4
	},
	"bestPrice": 205.4,
	"cheapestSource": "skyscanner",
	"sourcesFound": ["skyscanner", "kayak", "priceline", "expedia"],
	"currency": "USD",
	"airline": "jetBlue",
	"from": {
		"code": "LAX",
		"name": "Los Angeles International",
		"city": "Los Angeles",
		"country": "United States",
		"countryCode": "US"
	},
	"to": {
		"code": "JFK",
		"name": "New York John F. Kennedy",
		"city": "New York",
		"country": "United States",
		"countryCode": "US"
	},
	"departDate": "2026-07-15",
	"departTime": "14:30",
	"arriveDate": "2026-07-15",
	"arriveTime": "23:10",
	"duration": "5 hr 40 min",
	"durationMinutes": 340,
	"stops": 0,
	"segments": [
		{
			"airline": "jetBlue",
			"airlineCode": "B6",
			"flightNumber": "B6624",
			"from": {
				"code": "LAX",
				"name": "Los Angeles International",
				"city": "Los Angeles",
				"country": "United States",
				"countryCode": "US"
			},
			"to": {
				"code": "JFK",
				"name": "New York John F. Kennedy",
				"city": "New York",
				"country": "United States",
				"countryCode": "US"
			},
			"departureTime": "14:30",
			"arrivalTime": "23:10",
			"durationMinutes": 340,
			"cabinClass": "economy"
		}
	],
	"layovers": [],
	"baggage": {
		"personalItemIncluded": null,
		"carryOnBagsIncluded": null,
		"checkedBagsIncluded": null
	},
	"highlights": {
		"isBest": true,
		"isCheapest": true,
		"isFastest": false,
		"recommendationReason": "Cheapest matching itinerary"
	},
	"isSelfTransfer": false,
	"travelHack": {
		"isVirtualInterlining": false,
		"isHiddenCity": false,
		"isThrowawayTicket": false
	},
	"links": {
		"book": "https://www.skyscanner.com/",
		"skyscanner": "https://www.skyscanner.com/"
	},
	"scrapedAt": "2026-06-05T21:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each saved flight itinerary. If no matching public itinerary is saved, no itinerary event is charged.

The configured pricing event is `Flight itinerary` at `$0.00225` per saved itinerary.

### ⚠️ Limits and caveats

Public flight sources can show different prices, currencies, baggage details, and booking links. The Actor returns the public data available during the run, but fares can change after scraping.

Some routes or dates may return fewer rows than your requested limit. If a source is unavailable or does not return date-correct itinerary details, the Actor skips that source instead of saving placeholder rows.

Round-trip support depends on the source data available for the submitted route. For the broadest first-run coverage, start with one-way airport-code searches.

### ❓ FAQ

#### 🔌 Can I use this as a flight prices API?

Yes. You can run the Actor from Apify Console or through the Apify API and read the dataset rows from your app, workflow, or dashboard.

#### 🔑 Does it need a flight API key?

No public input asks for a Google Flights, Skyscanner, Kayak, Kiwi, Ryanair, or easyJet API key. The Actor handles public source access internally.

#### 🧭 Does it scrape every airline website directly?

No. It searches public flight sources and airline surfaces that return itinerary-grade data. If a direct airline surface only exposes calendar-level prices without full itinerary details, the Actor does not save those as fake flight rows.

#### 💸 Why do sources sometimes disagree on price?

Flight metasearch and airline sources can update at different times or include different booking options. Use `prices`, `bestPrice`, `cheapestSource`, and `sourcesFound` to compare what each source returned for the same itinerary.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [Award Flights Scraper ↗](https://apify.com/maximedupre/award-flights-scraper) - check award flight availability, miles, taxes, cabins, and booking links.
- [Google Maps Shared List Scraper ↗](https://apify.com/maximedupre/google-maps-shared-list-scraper) - export saved places from public Google Maps shared lists for travel planning and local research.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - crawl rendered websites and export discovered links with source-page context.
- [Web Images Scraper ↗](https://apify.com/maximedupre/web-images-scraper) - extract image URLs, metadata, source pages, and optional saved image files from public webpages.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - collect paid Shopping ad products, prices, merchants, and landing pages from Google Search.

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

# Actor input Schema

## `tripType` (type: `string`):

Choose whether to search one-way or round-trip flights.

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

Departure city, airport name, or IATA code, such as LAX or Los Angeles.

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

Arrival city, airport name, or IATA code, such as JFK or New York.

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

Date to search for outbound flights.

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

Optional return date for round-trip searches. Leave empty for one-way searches.

## `passengers` (type: `integer`):

Number of adult passengers to price.

## `currency` (type: `string`):

ISO currency code for prices, such as USD, EUR, GBP, CAD, or AUD.

## `cabinClass` (type: `string`):

Cabin class to search.

## `maxStops` (type: `string`):

Maximum number of stops to keep.

## `maxPrice` (type: `integer`):

Optional maximum price per passenger in the selected currency.

## `preferredAirlines` (type: `array`):

Optional airline names or IATA codes to prefer, such as Delta or DL.

## `excludedAirlines` (type: `array`):

Optional airline names or IATA codes to remove from results, such as Spirit or NK.

## `departureTimeFrom` (type: `string`):

Optional earliest departure time in 24-hour format, such as 06:00.

## `departureTimeTo` (type: `string`):

Optional latest departure time in 24-hour format, such as 20:00.

## `arrivalTimeBefore` (type: `string`):

Optional latest arrival time in 24-hour format, such as 22:00.

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

Choose how results are ranked before the limit is applied.

## `includeBaggageEstimate` (type: `boolean`):

Add included personal item, carry-on, and checked-bag allowance fields when public fare data is available.

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

Maximum itinerary rows to save. Start small for a quick first run.

## Actor input object example

```json
{
  "tripType": "oneWay",
  "origin": "LAX",
  "destination": "JFK",
  "departureDate": "2026-07-15",
  "passengers": 1,
  "currency": "USD",
  "cabinClass": "economy",
  "maxStops": "any",
  "sortBy": "balanced",
  "includeBaggageEstimate": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Open the dataset of flight itinerary rows.

# 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": "LAX",
    "destination": "JFK",
    "departureDate": "2026-07-15"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/flight-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": "LAX",
    "destination": "JFK",
    "departureDate": "2026-07-15",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/flight-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": "LAX",
  "destination": "JFK",
  "departureDate": "2026-07-15"
}' |
apify call maximedupre/flight-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flight Scraper",
        "description": "Flight scraper for public route searches. Compare itinerary prices, airlines, times, stops, duration, baggage hints, and booking links from multiple flight sources.",
        "version": "0.1",
        "x-build-id": "epXXpspSvBn168jnq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~flight-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-flight-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~flight-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-flight-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~flight-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-flight-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": [
                    "tripType",
                    "origin",
                    "destination",
                    "departureDate",
                    "maxResults",
                    "passengers",
                    "currency",
                    "sortBy",
                    "cabinClass",
                    "maxStops",
                    "includeBaggageEstimate"
                ],
                "properties": {
                    "tripType": {
                        "title": "Trip type",
                        "enum": [
                            "oneWay",
                            "roundTrip"
                        ],
                        "type": "string",
                        "description": "Choose whether to search one-way or round-trip flights.",
                        "default": "oneWay"
                    },
                    "origin": {
                        "title": "Origin",
                        "minLength": 2,
                        "type": "string",
                        "description": "Departure city, airport name, or IATA code, such as LAX or Los Angeles."
                    },
                    "destination": {
                        "title": "Destination",
                        "minLength": 2,
                        "type": "string",
                        "description": "Arrival city, airport name, or IATA code, such as JFK or New York."
                    },
                    "departureDate": {
                        "title": "Departure date",
                        "type": "string",
                        "description": "Date to search for outbound flights."
                    },
                    "returnDate": {
                        "title": "Return date",
                        "type": "string",
                        "description": "Optional return date for round-trip searches. Leave empty for one-way searches."
                    },
                    "passengers": {
                        "title": "Passengers",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers to price.",
                        "default": 1
                    },
                    "currency": {
                        "title": "Currency",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "ISO currency code for prices, such as USD, EUR, GBP, CAD, or AUD.",
                        "default": "USD"
                    },
                    "cabinClass": {
                        "title": "Cabin class",
                        "enum": [
                            "economy",
                            "premiumEconomy",
                            "business",
                            "first"
                        ],
                        "type": "string",
                        "description": "Cabin class to search.",
                        "default": "economy"
                    },
                    "maxStops": {
                        "title": "Stops",
                        "enum": [
                            "any",
                            "nonstop",
                            "oneStop",
                            "twoStops"
                        ],
                        "type": "string",
                        "description": "Maximum number of stops to keep.",
                        "default": "any"
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum price per passenger in the selected currency."
                    },
                    "preferredAirlines": {
                        "title": "Preferred airlines",
                        "type": "array",
                        "description": "Optional airline names or IATA codes to prefer, such as Delta or DL.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "excludedAirlines": {
                        "title": "Excluded airlines",
                        "type": "array",
                        "description": "Optional airline names or IATA codes to remove from results, such as Spirit or NK.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "departureTimeFrom": {
                        "title": "Earliest departure time",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
                        "type": "string",
                        "description": "Optional earliest departure time in 24-hour format, such as 06:00."
                    },
                    "departureTimeTo": {
                        "title": "Latest departure time",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
                        "type": "string",
                        "description": "Optional latest departure time in 24-hour format, such as 20:00."
                    },
                    "arrivalTimeBefore": {
                        "title": "Arrive before",
                        "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$",
                        "type": "string",
                        "description": "Optional latest arrival time in 24-hour format, such as 22:00."
                    },
                    "sortBy": {
                        "title": "Sort flights by",
                        "enum": [
                            "balanced",
                            "cheapest",
                            "fastest",
                            "nonstopFirst"
                        ],
                        "type": "string",
                        "description": "Choose how results are ranked before the limit is applied.",
                        "default": "balanced"
                    },
                    "includeBaggageEstimate": {
                        "title": "Add baggage allowance",
                        "type": "boolean",
                        "description": "Add included personal item, carry-on, and checked-bag allowance fields when public fare data is available.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Flight result limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum itinerary rows to save. Start small for a quick first run.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
