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

Extract Google Flights fares: airline, departure and arrival times, duration, stops, price, baggage and CO2. One-way or round-trip with cabin and stop filters, plus a cheapest-fare-per-date price grid. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/google-flights-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 flight results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Flights Scraper

Scrape Google Flights from **$0.80 / 1,000 flight results** and pull up to 100 ranked fares per route in a single run. Drop in an origin, a destination and a date, then export clean per-flight rows: airline, departure and arrival times, duration, stops, price, cabin class, baggage allowance and CO2 emissions. Filter by cabin - economy, premium economy, business or first - to track premium seats, where business fares on SFO to NRT run 5 to 8 times the economy price. One-way or round-trip, with an optional cheapest-fare-per-date price grid of up to 60 days.

You pay only for the rows you receive. Diagnostic and error rows are never charged.

### Why this Actor?

| Capability | This Actor | Typical alternatives |
|---|---|---|
| One-way and round-trip | **Both from one input form** | One-way focus |
| Stops filter | **Nonstop, 1, 2 or 3 stops** | Limited or none |
| Sort modes | **5: best, price, duration, departure, arrival** | Single default order |
| Cabin classes | **4: economy, premium economy, business, first** | economy only |
| Cheapest-fare price calendar | **Up to 60 days per route** | Single date only, no calendar |
| CO2 emissions per itinerary | **Included on each flight** | Not available |
| Baggage fields per fare | **Carry-on and checked** | Rarely exposed |
| Pricing currencies | **10, including USD, EUR, GBP and JPY** | 1 to 2 |
| Pricing model | **Pay per result, from $0.80 / 1,000** | Flat monthly plans |

### What does the Google Flights Scraper do?

The Google Flights Scraper turns a route and a date into structured flight data you can use in a spreadsheet, a dashboard or a pipeline. Give it an origin, a destination and a departure date (add a return date for a round-trip), and it returns one clean row per flight offer with the airline, schedule, price and travel details already parsed.

Need to know the cheapest day to fly? Switch on the price grid and the actor adds a calendar of the lowest fare per date around your departure, so you can spot the best window at a glance. Filters for stops, passenger count, sort order and pricing currency let you target the exact fares you care about.

The input form comes prefilled with a working JFK to LAX example, so you can press **Start** and see real flight rows on the first run, then change the route and filters to fit your use case.

### What data can you get from Google Flights?

Each flight row includes:

- Airline and flight number
- Departure airport and arrival airport
- Departure time and arrival time
- Duration in minutes
- Number of stops and the stop airports
- Price and currency
- Cabin class and fare type of the returned fare
- Carry-on and checked baggage allowance
- Wi-Fi availability
- CO2 emissions in kilograms
- Best-flight flag from Google ranking

Each price-grid row includes the date, the minimum price for that date and the currency, so you get a ready-made cheapest-fare calendar.

### Input modes

Each mode below maps to a ready-to-run task. Copy a block into the input editor, change the route or dates, and press **Start**.

#### 1. Cheapest fares on a route

Find the lowest fares between two airports on a set date, sorted price-first for deal hunters and fare trackers.

```json
{"origin": "JFK", "destination": "LAX", "departureDate": "2026-09-15", "sort": "price", "maxResults": 50}
````

#### 2. Nonstop only

Return direct flights only, ideal for premium travelers and corporate booking tools that skip layovers.

```json
{"origin": "JFK", "destination": "LHR", "departureDate": "2026-09-15", "maxStops": "0", "maxResults": 50}
```

#### 3. Round trip

Price an outbound and a return together for a holiday or beach trip, one clean row per offer.

```json
{"origin": "MIA", "destination": "CUN", "departureDate": "2026-09-15", "returnDate": "2026-09-22", "maxResults": 50}
```

#### 4. 30-day price calendar

Build a cheapest-fare-per-day calendar across a month to spot the best date to book.

```json
{"origin": "LAX", "destination": "JFK", "departureDate": "2026-09-15", "includePriceGrid": true, "priceGridDays": 30, "maxResults": 20}
```

#### 5. Shortest flights

Rank offers by travel time so you surface the fastest connection on time-sensitive routes.

```json
{"origin": "ORD", "destination": "DEN", "departureDate": "2026-09-15", "sort": "duration", "maxResults": 50}
```

#### 6. Business and first-class fares

Monitor premium-cabin pricing for corporate travel desks and business flyers. On SFO to NRT, business fares measured 5 to 8 times above economy, so a dedicated cabin filter keeps the premium seats in view.

```json
{"origin": "SFO", "destination": "NRT", "departureDate": "2026-09-15", "cabinClass": "business", "sort": "price", "maxResults": 50}
```

### How to scrape Google Flights

1. Open the actor and look at the input form. It is prefilled with a JFK to LAX example, so you can run it straight away.
2. Set the **Origin** and **Destination** as IATA codes (JFK, LAX) or city names.
3. Set the **Departure date** in YYYY-MM-DD format. Add a **Return date** for a round-trip, or leave it blank for one-way.
4. Open the **Filters** section to choose max stops, cabin class, passenger count, sort order and currency.
5. Open the **Price grid** section and enable it if you want a cheapest-fare-per-date calendar of up to 60 days.
6. Press **Start**, then export the results as JSON, CSV, Excel or Google Sheets, or pull them from the Apify API.

### Output example

Results are flat rows split by `row_type` into ready-made table views: **Flights** and **Price grid**. Diagnostic rows carry an `error_code` and are never charged.

| row\_type | Key fields | What it holds |
|---|---|---|
| `flight` | `price`, `stops`, `duration_minutes`, `co2_emissions_kg`, `baggage_carry_on`, `baggage_checked`, `airline`, `cabin_class` | One flight offer |
| `price_date` | `date`, `min_price`, `currency` | One day in the cheapest-fare calendar |
| `error` | `error_code`, `error_message` | Diagnostic row, free |

Baggage, Wi-Fi and fare-type fields populate when Google exposes them for the fare, and read `null` otherwise.

A `flight` row (real JFK to LAX result):

```json
{
  "query": "JFK-LAX",
  "row_type": "flight",
  "airline": "American",
  "flight_number": "AA33",
  "departure_airport": "JFK",
  "arrival_airport": "LAX",
  "departure_time": "2026-07-15 07:05",
  "arrival_time": "2026-07-15 10:07",
  "duration_minutes": 362,
  "stops": 0,
  "stop_airports": [],
  "price": 433.0,
  "currency": "USD",
  "cabin_class": "economy",
  "fare_type": null,
  "baggage_carry_on": null,
  "baggage_checked": null,
  "has_wifi": null,
  "co2_emissions_kg": 546.0,
  "is_best": true
}
```

A `price_date` row:

```json
{
  "query": "LAX-JFK",
  "row_type": "price_date",
  "date": "2026-09-18",
  "min_price": 288,
  "currency": "USD"
}
```

### How much does it cost to scrape Google Flights?

Pricing is pay-per-result, so your bill matches the data you actually collect:

- **flight-result**: $0.0008 per flight row, which is $0.80 per 1,000 flight rows.
- **price-date**: $0.004 per calendar date, which is $4 per 1,000 dates. The price grid is heavier because it prices a separate fare search for each date.

Apify gives new accounts $5 in free monthly credit. That covers about **6,250 flight rows** at the flight-result rate before you spend a cent of your own. Leave the price grid off when you only need the flight list, and turn it on when the cheapest-day calendar is worth the heavier per-date charge. Error rows are pushed for visibility and are never charged.

### What can you use Google Flights data for?

- **Fare monitoring** - track prices on a route across stops and airlines over time.
- **Cheapest-day discovery** - use the price grid to find the lowest fare window before booking.
- **Travel dashboards** - feed live fare rows into your own reporting and price-alert tools.
- **Competitor and market research** - compare how carriers price the same city pair.
- **Price prediction models** - build datasets of historical fares to train forecasting.
- **Corporate travel budgeting** - estimate route costs by passenger count and travel date.
- **OTA and affiliate sites** - power flight comparison widgets with structured offers.
- **Sustainability reporting** - use CO2 emissions per flight for greener travel choices.
- **Deal alert services** - notify users when a tracked route drops below a target price.

### Is it legal to scrape Google Flights?

Scraping publicly available information is legal in many jurisdictions, and this actor only collects public flight listings, prices and schedules that anyone can view on Google Flights without an account. It does not touch private accounts or personal data. You are responsible for how you use the data, so review Google's terms and any local rules that apply to your project, and consult a lawyer if you need certainty for a commercial deployment.

### Related actors

Building a travel data stack? Pair this with other Data Forge actors:

- **[Booking.com Hotels Scraper](https://apify.com/jdtpnjtp/booking-hotels-scraper)** - search a destination for hotels with live prices, review scores and detail pages.
- **[Booking.com Airport Taxis Scraper](https://apify.com/jdtpnjtp/booking-airport-taxis-scraper)** - price airport transfers and private rides for the same trip.
- **[TripAdvisor Scraper](https://apify.com/jdtpnjtp/tripadvisor)** - search a destination across hotels, restaurants, things to do, vacation rentals and cruises.

### FAQ

**Can I search one-way and round-trip?** Yes. Add a `returnDate` for a round-trip, or leave it blank for one-way.

**Can I filter by cabin class?** Yes. Set `cabinClass` to economy, premium economy, business or first, and the actor returns fares for that cabin. Premium cabins price well above economy - on SFO to NRT, business measured 5 to 8 times the economy fare and first ran past $11,000.

**How do I find the cheapest day to fly?** Enable the price grid and set `priceGridDays` up to 60. The actor returns the lowest fare per date as a calendar.

**Can I use airport codes and city names?** Both work for the origin and destination fields. IATA codes such as JFK and LAX give the most precise match.

**How fresh are the fares?** They are live at run time. Each run queries Google Flights in real time, so prices reflect the market at the moment the run starts, not a cached snapshot.

**Why might a price differ at checkout?** Google Flights shows the lowest current offers from carriers and travel agencies, and seat availability and fares move minute to minute. For a booking decision, re-run the route right before you buy.

**Can I schedule daily fare monitoring?** Yes. Use the Apify Scheduler to run a route on a daily or hourly schedule and append rows to one dataset, building a fare-history table for price alerts and trend charts.

**Can I run it from the API or an integration?** Yes. Start runs and fetch results through the Apify API, the JavaScript and Python clients, webhooks, or the Apify MCP server for AI agents.

**What happens if a search fails?** The actor pushes a diagnostic row with an error code so you can see what happened. These rows are never charged.

**Which export formats are supported?** JSON, CSV, Excel and Google Sheets, plus direct dataset access over the API.

**Is it legal to scrape Google Flights?** It collects public flight listings, prices and schedules, not private accounts or personal data. See the legality section above and review Google's terms for your use case.

### Support

Built and maintained by **Data Forge**. Need custom fields, higher volume or help getting started?

[![Telegram](https://img.shields.io/badge/Telegram-Chat-26A5E4?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-Message-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-Contact-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

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

Origin airport IATA code (for example JFK) or a city name (for example New York). The form is prefilled so you can run it as-is.

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

Destination airport IATA code (for example LAX) or a city name (for example Los Angeles).

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

Outbound date in YYYY-MM-DD format (for example 2026-07-15).

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

Optional return date in YYYY-MM-DD format for a round-trip. Leave blank for a one-way search.

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

Number of adult passengers to price the fares for.

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

Upper bound on the number of flight rows returned per run (1 to 100). Keep it low to control cost.

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

Cabin to search fares in.

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

Maximum number of stops per itinerary. Leave on Any for no limit.

## `sort` (type: `string`):

Order the returned flights.

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

ISO currency code used to price the fares.

## `includePriceGrid` (type: `boolean`):

Also build a cheapest-fare-per-date calendar around the departure date. Each date adds one price-date charge, so this is heavier than a plain search.

## `priceGridDays` (type: `integer`):

Number of days to include in the price grid when it is enabled (1 to 60).

## Actor input object example

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-07-15",
  "returnDate": "",
  "adults": 1,
  "maxResults": 30,
  "cabinClass": "economy",
  "maxStops": "",
  "sort": "best",
  "currency": "USD",
  "includePriceGrid": false,
  "priceGridDays": 14
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; row\_type discriminates flight vs price\_date. Full payload (legs, layovers) under data.

## `summary` (type: `string`):

OUTPUT key: flights, price\_dates, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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": "JFK",
    "destination": "LAX",
    "departureDate": "2026-07-15",
    "adults": 1,
    "maxResults": 30,
    "priceGridDays": 14
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/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 = {
    "origin": "JFK",
    "destination": "LAX",
    "departureDate": "2026-07-15",
    "adults": 1,
    "maxResults": 30,
    "priceGridDays": 14,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/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 '{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-07-15",
  "adults": 1,
  "maxResults": 30,
  "priceGridDays": 14
}' |
apify call jdtpnjtp/google-flights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Flights Scraper",
        "description": "Extract Google Flights fares: airline, departure and arrival times, duration, stops, price, baggage and CO2. One-way or round-trip with cabin and stop filters, plus a cheapest-fare-per-date price grid. Pay per result.",
        "version": "1.0",
        "x-build-id": "zBa5bCVReTceuViCn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~google-flights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-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/jdtpnjtp~google-flights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-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/jdtpnjtp~google-flights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-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",
                "properties": {
                    "origin": {
                        "title": "Origin",
                        "type": "string",
                        "description": "Origin airport IATA code (for example JFK) or a city name (for example New York). The form is prefilled so you can run it as-is."
                    },
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "Destination airport IATA code (for example LAX) or a city name (for example Los Angeles)."
                    },
                    "departureDate": {
                        "title": "Departure date",
                        "type": "string",
                        "description": "Outbound date in YYYY-MM-DD format (for example 2026-07-15)."
                    },
                    "returnDate": {
                        "title": "Return date",
                        "type": "string",
                        "description": "Optional return date in YYYY-MM-DD format for a round-trip. Leave blank for a one-way search.",
                        "default": ""
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers to price the fares for."
                    },
                    "maxResults": {
                        "title": "Max flights",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Upper bound on the number of flight rows returned per run (1 to 100). Keep it low to control cost."
                    },
                    "cabinClass": {
                        "title": "Cabin class",
                        "enum": [
                            "economy",
                            "premium_economy",
                            "business",
                            "first"
                        ],
                        "type": "string",
                        "description": "Cabin to search fares in.",
                        "default": "economy"
                    },
                    "maxStops": {
                        "title": "Max stops",
                        "enum": [
                            "",
                            "0",
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "Maximum number of stops per itinerary. Leave on Any for no limit.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "best",
                            "price",
                            "duration",
                            "departure_time",
                            "arrival_time"
                        ],
                        "type": "string",
                        "description": "Order the returned flights.",
                        "default": "best"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "INR",
                            "BRL",
                            "MXN",
                            "AED"
                        ],
                        "type": "string",
                        "description": "ISO currency code used to price the fares.",
                        "default": "USD"
                    },
                    "includePriceGrid": {
                        "title": "Include price grid",
                        "type": "boolean",
                        "description": "Also build a cheapest-fare-per-date calendar around the departure date. Each date adds one price-date charge, so this is heavier than a plain search.",
                        "default": false
                    },
                    "priceGridDays": {
                        "title": "Price grid days",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Number of days to include in the price grid when it is enabled (1 to 60)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
