# Google Flights Scraper (`crawlerbros/google-flights-scraper`) Actor

Scrape Google Flights search results with price, airline, departure/arrival times, duration, stops. One-way + round-trip + cabin class + airline filters: maxLayoverMinutes, directOnly, excludeBasicEconomy.

- **URL**: https://apify.com/crawlerbros/google-flights-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Google Flights Scraper

Search Google Flights and emit one structured record per flight option — price, airline, departure/arrival times, duration, and stop count. One-way and round-trip in 4 cabin classes. Pro filters narrow the result set to exactly the flights you want.

### What this actor does

- Builds a Google Flights search URL from your airports + dates + cabin class
- Drives a headless Chromium (Playwright) through Apify residential proxy
- Dismisses cookie banners and "Show more flights" buttons
- Parses each flight option from the rendered DOM aria-labels
- Applies Pro filters (airline, stops, layover, duration, fare type)
- Emits one record per flight option

### Output per flight option

- `price` (integer, normalised to your `currency` input), `currency`
- `airline` (display name), `airlineCode` (IATA, when resolvable)
- `flightNumber` (when extractable)
- `departureAirport` (IATA), `departureTime`
- `arrivalAirport` (IATA), `arrivalTime`
- `durationMinutes`, `pricePerHour` (derived)
- `stops`
- `cabin`, `outboundDate`, `returnDate` (echoed from input)
- `priceBelowThreshold` — only when `priceAlertThresholdUsd` is set
- `recordType: "flight"`, `scrapedAt`

Empty fields are omitted from the output (no nulls).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `originAirport` | string | `JFK` | Origin IATA (3 letters) |
| `destinationAirport` | string | `LHR` | Destination IATA |
| `outboundDate` | string | 30 days ahead | Departure date `YYYY-MM-DD` |
| `returnDate` | string | – | Return date — empty for one-way |
| `adults` | int | `1` | Adult passengers (1–9) |
| `children` | int | `0` | Child passengers (0–9) |
| `infants` | int | `0` | Infant passengers (0–9) |
| `cabinClass` | enum | `economy` | `economy` / `premium_economy` / `business` / `first` |
| `currency` | enum | `USD` | Display currency |
| `language` | enum | `en` | Google Flights UI language |
| `country` | enum | `US` | `gl` country code |
| `maxStops` | enum | `any` | `any` / `nonstop` / `one_stop` / `two_or_fewer` |
| `airlines` | array | `[]` | IATA airline allowlist (e.g. `["UA","DL"]`) |
| `excludeAirlines` | array | `[]` | IATA airline blocklist |
| `maxResults` | int | `50` | Hard cap on emitted records |
| `minPrice` | int | – | Drop flights below this price (in chosen `currency`) |
| `maxPrice` | int | – | Drop flights above this price |
| `directOnly` | bool | `false` | Alias for `maxStops=nonstop` |
| `maxLayoverMinutes` | int | – | Drop connections with a layover longer than this |
| `maxDurationMinutes` | int | – | Drop flights longer than this many minutes |
| `excludeBasicEconomy` | bool | `false` | Drop fares labelled Basic / Light / Saver |
| `priceAlertThresholdUsd` | number | – | Tag flights at-or-below this price with `priceBelowThreshold: true` |
| `useApifyProxy` | bool | `true` | Route through Apify residential proxy (recommended) |

#### Example: cheapest round-trip JFK → LHR

```json
{
  "originAirport": "JFK",
  "destinationAirport": "LHR",
  "outboundDate": "2026-06-15",
  "returnDate": "2026-06-22",
  "cabinClass": "economy",
  "directOnly": true,
  "maxResults": 25
}
````

#### Example: business-class SFO → HND with airline allowlist

```json
{
  "originAirport": "SFO",
  "destinationAirport": "HND",
  "outboundDate": "2026-09-10",
  "returnDate": "2026-09-25",
  "cabinClass": "business",
  "airlines": ["NH", "JL", "UA"],
  "maxLayoverMinutes": 240
}
```

#### Example: one-way budget search with price alert

```json
{
  "originAirport": "LAX",
  "destinationAirport": "MEX",
  "outboundDate": "2026-04-30",
  "cabinClass": "economy",
  "maxResults": 50,
  "priceAlertThresholdUsd": 200
}
```

### Use cases

- **Travel-deal alerts** — daily run with `priceAlertThresholdUsd`, push the matched flights to Slack
- **Corporate travel benchmarking** — weekly export of business-class prices on key routes
- **Price-tracking dashboards** — feed each flight option into a time-series store
- **Itinerary planning** — combine with a hotel scraper for end-to-end trip cost
- **Frequent-flyer comparison** — enrich with our `flight-award-scraper-pro` to compare cash vs. miles

### FAQ

**Does it require a login or cookies?**  No.

**Why does it need an Apify residential proxy?**  Google rate-limits cloud datacenter IPs aggressively on Flights URLs — without a residential exit you'll typically hit a 429 or captcha. The actor uses Apify residential by default.

**Why is `airlineCode` sometimes missing?**  Some airlines aren't in our name → IATA lookup yet (we cover ~50 carriers). The display name is always populated when extracted; the code is best-effort.

**Why does the run sometimes return 0 flights?**  Causes (in order of likelihood): (1) Google captcha blocked the page (rotate proxy and retry), (2) the route has no flights on those dates, (3) every flight was filtered out by your Pro filters, (4) Google's DOM changed faster than our extraction. The status message tells you which.

**Are multi-city itineraries supported?**  Not in this MVP. Use multiple separate runs with different origin/destination/date pairs.

**Can I get a direct booking link?**  Booking-deeplink resolution is on the roadmap — Google Flights routes booking through an OTA selector that requires deeper interaction. The current actor returns the price/airline/duration/stops you need to make booking decisions.

**What's the difference between `economy` and `excludeBasicEconomy`?**  `cabinClass=economy` searches the economy cabin (covers Basic, Main, and Premium variants). `excludeBasicEconomy` drops the cheapest fares within that cabin (those labelled Basic / Light / Saver) — useful when you want a reliable Main Cabin baseline.

**Is the price guaranteed?**  No. Google Flights prices are advisory; the actual price is set by the airline / OTA at booking time. We capture the displayed price at scrape time.

# Actor input Schema

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

Three-letter IATA airport code, e.g. `JFK`, `LHR`, `SFO`.

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

Three-letter IATA airport code.

## `outboundDate` (type: `string`):

Outbound (departure) date. Defaults to 30 days from today when empty.

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

Set for round-trip search. Empty for one-way.

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

Number of adult passengers (1-9).

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

Number of child passengers (0-9).

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

Number of infant passengers (0-9).

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

Cabin to search.

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

Currency code Google Flights should display (USD/EUR/GBP/...). The actor parses the displayed price using this currency.

## `language` (type: `string`):

Google Flights UI language.

## `country` (type: `string`):

Country code passed to Google Flights for regional pricing/availability.

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

Maximum stops on a single leg.

## `airlines` (type: `array`):

Two-letter IATA airline codes — e.g. `["UA","DL"]`. Empty = all airlines.

## `excludeAirlines` (type: `array`):

Two-letter IATA airline codes to exclude.

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

Hard cap on emitted flight options.

## `minPrice` (type: `integer`):

Drop flights below this price (in the chosen `currency`).

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

Drop flights above this price (in the chosen `currency`).

## `directOnly` (type: `boolean`):

Alias for `maxStops=nonstop`. When true, drops connecting flights.

## `maxLayoverMinutes` (type: `integer`):

Drop connecting flights with a layover longer than this. Ignored on nonstop searches.

## `maxDurationMinutes` (type: `integer`):

Drop flights whose total duration exceeds this many minutes.

## `excludeBasicEconomy` (type: `boolean`):

Drop flights labelled `Basic Economy` / `Light` / `Saver`.

## `priceAlertThresholdUsd` (type: `number`):

When set, flights at or below this price get an extra `priceBelowThreshold: true` field.

## `useApifyProxy` (type: `boolean`):

Route through Apify's residential pool. Strongly recommended — Google Flights rate-limits cloud datacenter IPs aggressively.

## Actor input object example

```json
{
  "originAirport": "JFK",
  "destinationAirport": "LHR",
  "adults": 1,
  "children": 0,
  "infants": 0,
  "cabinClass": "economy",
  "currency": "USD",
  "language": "en",
  "country": "US",
  "maxStops": "any",
  "airlines": [],
  "excludeAirlines": [],
  "maxResults": 50,
  "directOnly": false,
  "excludeBasicEconomy": false,
  "useApifyProxy": true
}
```

# 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": "JFK",
    "destinationAirport": "LHR",
    "adults": 1,
    "children": 0,
    "infants": 0,
    "cabinClass": "economy",
    "currency": "USD",
    "language": "en",
    "country": "US",
    "maxStops": "any",
    "airlines": [],
    "excludeAirlines": [],
    "maxResults": 50,
    "directOnly": false,
    "excludeBasicEconomy": false,
    "useApifyProxy": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-flights-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": "JFK",
    "destinationAirport": "LHR",
    "adults": 1,
    "children": 0,
    "infants": 0,
    "cabinClass": "economy",
    "currency": "USD",
    "language": "en",
    "country": "US",
    "maxStops": "any",
    "airlines": [],
    "excludeAirlines": [],
    "maxResults": 50,
    "directOnly": False,
    "excludeBasicEconomy": False,
    "useApifyProxy": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-flights-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": "JFK",
  "destinationAirport": "LHR",
  "adults": 1,
  "children": 0,
  "infants": 0,
  "cabinClass": "economy",
  "currency": "USD",
  "language": "en",
  "country": "US",
  "maxStops": "any",
  "airlines": [],
  "excludeAirlines": [],
  "maxResults": 50,
  "directOnly": false,
  "excludeBasicEconomy": false,
  "useApifyProxy": true
}' |
apify call crawlerbros/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Flights Scraper",
        "description": "Scrape Google Flights search results with price, airline, departure/arrival times, duration, stops. One-way + round-trip + cabin class + airline filters: maxLayoverMinutes, directOnly, excludeBasicEconomy.",
        "version": "1.0",
        "x-build-id": "FRRCo0z0MCTRu1zvo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-flights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-flights-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/crawlerbros~google-flights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-flights-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/crawlerbros~google-flights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-flights-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"
                ],
                "properties": {
                    "originAirport": {
                        "title": "Origin airport (IATA)",
                        "type": "string",
                        "description": "Three-letter IATA airport code, e.g. `JFK`, `LHR`, `SFO`.",
                        "default": "JFK"
                    },
                    "destinationAirport": {
                        "title": "Destination airport (IATA)",
                        "type": "string",
                        "description": "Three-letter IATA airport code.",
                        "default": "LHR"
                    },
                    "outboundDate": {
                        "title": "Outbound date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Outbound (departure) date. Defaults to 30 days from today when empty."
                    },
                    "returnDate": {
                        "title": "Return date (YYYY-MM-DD, optional)",
                        "type": "string",
                        "description": "Set for round-trip search. Empty for one-way."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers (1-9).",
                        "default": 1
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of child passengers (0-9).",
                        "default": 0
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of infant passengers (0-9).",
                        "default": 0
                    },
                    "cabinClass": {
                        "title": "Cabin class",
                        "enum": [
                            "economy",
                            "premium_economy",
                            "business",
                            "first"
                        ],
                        "type": "string",
                        "description": "Cabin to search.",
                        "default": "economy"
                    },
                    "currency": {
                        "title": "Currency (display)",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "INR",
                            "BRL",
                            "CNY",
                            "CHF",
                            "HKD",
                            "MXN",
                            "NOK",
                            "NZD",
                            "SEK",
                            "SGD",
                            "ZAR",
                            "AED",
                            "KRW"
                        ],
                        "type": "string",
                        "description": "Currency code Google Flights should display (USD/EUR/GBP/...). The actor parses the displayed price using this currency.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW",
                            "ar",
                            "ru",
                            "hi",
                            "tr",
                            "nl",
                            "pl",
                            "sv",
                            "da",
                            "fi",
                            "no"
                        ],
                        "type": "string",
                        "description": "Google Flights UI language.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country (gl param)",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "IE",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "JP",
                            "KR",
                            "SG",
                            "IN",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Country code passed to Google Flights for regional pricing/availability.",
                        "default": "US"
                    },
                    "maxStops": {
                        "title": "Max stops",
                        "enum": [
                            "any",
                            "nonstop",
                            "one_stop",
                            "two_or_fewer"
                        ],
                        "type": "string",
                        "description": "Maximum stops on a single leg.",
                        "default": "any"
                    },
                    "airlines": {
                        "title": "Airlines allowlist (IATA)",
                        "type": "array",
                        "description": "Two-letter IATA airline codes — e.g. `[\"UA\",\"DL\"]`. Empty = all airlines.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeAirlines": {
                        "title": "Airlines blocklist (IATA)",
                        "type": "array",
                        "description": "Two-letter IATA airline codes to exclude.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted flight options.",
                        "default": 50
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop flights below this price (in the chosen `currency`)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop flights above this price (in the chosen `currency`)."
                    },
                    "directOnly": {
                        "title": "Direct flights only",
                        "type": "boolean",
                        "description": "Alias for `maxStops=nonstop`. When true, drops connecting flights.",
                        "default": false
                    },
                    "maxLayoverMinutes": {
                        "title": "Max layover minutes",
                        "minimum": 0,
                        "maximum": 2880,
                        "type": "integer",
                        "description": "Drop connecting flights with a layover longer than this. Ignored on nonstop searches."
                    },
                    "maxDurationMinutes": {
                        "title": "Max total duration minutes",
                        "minimum": 30,
                        "maximum": 4320,
                        "type": "integer",
                        "description": "Drop flights whose total duration exceeds this many minutes."
                    },
                    "excludeBasicEconomy": {
                        "title": "Exclude basic economy",
                        "type": "boolean",
                        "description": "Drop flights labelled `Basic Economy` / `Light` / `Saver`.",
                        "default": false
                    },
                    "priceAlertThresholdUsd": {
                        "title": "Price alert threshold USD",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "When set, flights at or below this price get an extra `priceBelowThreshold: true` field."
                    },
                    "useApifyProxy": {
                        "title": "Use Apify residential proxy",
                        "type": "boolean",
                        "description": "Route through Apify's residential pool. Strongly recommended — Google Flights rate-limits cloud datacenter IPs aggressively.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
