# Flightpoints Award Flights Scraper (`automation-lab/flightpoints-award-flights-scraper`) Actor

✈️ Scrape Flightpoints award-seat availability with miles, taxes, cabins, seats, programs, segments, and booking URLs.

- **URL**: https://apify.com/automation-lab/flightpoints-award-flights-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 award flight itineraries

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

## Flightpoints Award Flights Scraper

Find award-flight availability from Flightpoints and export itinerary-level data for miles, taxes, seats, cabins, loyalty programs, segments, and booking URLs.

### What does Flightpoints Award Flights Scraper do?

Flightpoints Award Flights Scraper searches the public Flightpoints award-flight API for a route and travel date.

It returns clean JSON rows for individual award-flight itineraries.

Each row includes the route, travel times, loyalty program, cabin availability, taxes, seats, booking URL, and segment details.

Use it to monitor high-value redemptions, compare programs, power dashboards, or build points-and-miles research workflows.

### Who is it for?

- ✈️ Award-travel bloggers tracking public saver availability.
- 💳 Points and miles consultants preparing client trip options.
- 🧳 Travel agencies comparing redemption choices for premium cabins.
- 📊 Deal-monitoring teams feeding internal dashboards.
- 🔔 Automation builders who need repeatable route/date checks.

### Why use this actor?

Manual award searches are repetitive.

Flightpoints already aggregates many program results.

This actor makes those results exportable from Apify.

You can schedule runs, connect datasets to downstream tools, and compare route/date changes over time.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Route | origin, destination, departure date |
| Time | departure time, arrival date, arrival time, duration |
| Program | loyalty program code, source, booking URL |
| Economy | miles, taxes, available seats |
| Premium economy | miles, taxes, available seats |
| Business | miles, taxes, available seats |
| First | miles, taxes, available seats |
| Sorting helpers | best cabin, best miles, best taxes, best seats |
| Segments | connection airports, flight numbers, airline codes |
| Metadata | search ID, last seen, scraped timestamp |

### How much does it cost to scrape Flightpoints award flights?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-itinerary fee for saved award-flight rows.

The default input is intentionally small so the first run stays inexpensive.

Configured pricing is a $0.005 start fee plus tiered per-itinerary pricing: FREE $0.000027473, BRONZE $0.00002389, SILVER $0.000018634, GOLD $0.000014334, PLATINUM $0.00001, and DIAMOND $0.00001 per saved itinerary.

### Quick start

1. Open the actor on Apify.
2. Enter an origin airport code such as `JFK`.
3. Enter a destination airport code such as `LHR`.
4. Pick a departure date.
5. Set `Maximum itineraries` to the number of rows you need.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, or through the API.

### Input overview

The main required inputs are:

- `origin` — three-letter IATA origin airport code.
- `destination` — three-letter IATA destination airport code.
- `departureDate` — travel date in YYYY-MM-DD format.

Optional filters include cabin, seats, direct flights, taxes, programs, and nearby dates.

### Example input

```json
{
  "origin": "JFK",
  "destination": "LHR",
  "departureDate": "2026-07-15",
  "maxResults": 50,
  "deltaDays": 0,
  "minimumSeats": 1,
  "includeSegments": true
}
````

### Output example

```json
{
  "origin": "JFK",
  "destination": "LHR",
  "departureDate": "2026-07-15",
  "program": "QF",
  "bestCabin": "Economy",
  "bestMiles": 23300,
  "bestTaxes": 349,
  "bestSeats": 1,
  "bookingUrl": "https://www.qantas.com"
}
```

### Tips for better results

- Use exact IATA airport codes.
- Start with one date before enabling date flexibility.
- Keep `maxResults` low for monitoring jobs.
- Use `minimumSeats` when searching for families or groups.
- Use `onlyDirectFlights` only when you specifically need non-stop options.
- Leave `programs` empty when comparing all loyalty programs.

### Cabin filters

You can filter for:

- Any cabin
- Economy
- Premium Economy
- Business
- First

The output still keeps cabin-specific fields so you can sort and compare rows downstream.

### Loyalty program filters

Use program codes such as:

- `AA` for American AAdvantage
- `AC` for Air Canada Aeroplan
- `BA` for British Airways Avios
- `UA` for United MileagePlus
- `VS` for Virgin Atlantic Flying Club

Leave the list empty to search all programs returned by Flightpoints.

### Date flexibility

`deltaDays` asks Flightpoints to search nearby dates.

A larger date window can return more results and take longer.

For scheduled monitoring, start with `0` or `1`.

### Segment details

When `includeSegments` is enabled, each itinerary can include connecting flight segments.

Segment data may include origin, destination, departure time, arrival time, airline code, and flight number.

Disable segment details if you only need compact rows.

### Integrations

Use the actor with:

- Google Sheets for weekly award availability reports.
- Make or Zapier for alert workflows.
- BigQuery or Snowflake for route history analysis.
- Slack notifications for newly available seats.
- Custom dashboards for points-and-miles teams.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/flightpoints-award-flights-scraper').call({
  origin: 'JFK',
  destination: 'LHR',
  departureDate: '2026-07-15',
  maxResults: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/flightpoints-award-flights-scraper').call(run_input={
    'origin': 'JFK',
    'destination': 'LHR',
    'departureDate': '2026-07-15',
    'maxResults': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~flightpoints-award-flights-scraper/runs?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"origin":"JFK","destination":"LHR","departureDate":"2026-07-15","maxResults":50}'
```

### MCP usage

Connect Apify MCP to Claude with this actor enabled:

`https://mcp.apify.com/?tools=automation-lab/flightpoints-award-flights-scraper`

Claude Code setup:

```bash
claude mcp add apify-flightpoints "https://mcp.apify.com/?tools=automation-lab/flightpoints-award-flights-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-flightpoints": {
      "url": "https://mcp.apify.com/?tools=automation-lab/flightpoints-award-flights-scraper"
    }
  }
}
```

Example prompts:

- "Search JFK to LHR award flights on July 15 and summarize the cheapest business-class options."
- "Run a Flightpoints award search for SFO to CDG and compare miles by program."
- "Find routes with at least two seats and taxes below 500."

### Scheduling ideas

Run daily for the same route/date.

Run weekly for a list of important premium-cabin routes.

Export results to a dashboard and compare new rows against yesterday's dataset.

### Troubleshooting

If you get no results, try a broader cabin filter or remove the direct-flight filter.

If a search is slow, lower `deltaDays` and `maxResults`.

If taxes look high, remember that some programs add carrier surcharges.

### Data freshness

Flightpoints can return cached or live availability depending on input and source state.

The actor includes `lastSeen` when Flightpoints provides it.

Use repeated scheduled runs for monitoring trends.

### Limitations

Availability can change quickly.

Booking URLs point to the loyalty program or source site and may require users to log in there.

The actor only extracts public Flightpoints search data.

It does not book tickets.

It does not access private user accounts.

### Legality

This actor extracts publicly accessible data.

Use the data responsibly and follow Apify terms, Flightpoints terms, and applicable laws.

Do not use scraped data for spam, fraud, or abusive automation.

### Related scrapers

Other automation-lab actors may help with travel and market workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Can I search multiple dates?

Use `deltaDays` for nearby-date flexibility. For a larger date series, schedule multiple runs.

#### Can I search multiple routes?

This MVP searches one origin and one destination per run for clean cost control. Use multiple runs for route portfolios.

#### Does it require a Flightpoints login?

No. The actor uses public Flightpoints search endpoints observed without login.

#### Does it include business and first class?

Yes. The output includes fields for economy, premium economy, business, and first where Flightpoints returns those cabins.

#### Why are there null cabin fields?

A null cabin value means that cabin was not available or not returned for that itinerary.

#### Can I use it for alerts?

Yes. Schedule the actor and compare new datasets with previous runs.

### Field reference

`id` is the source itinerary identifier.

`searchId` is the Flightpoints search key used for the run.

`bestCabin` is the cheapest available cabin by miles among cabins with seats.

`bestMiles` is the miles value for that cabin.

`bestTaxes` is the taxes/fees value for that cabin.

`segmentCount` is the number of connection segments returned.

`segments` contains detailed leg data when enabled.

### Version notes

The first version focuses on reliable HTTP extraction from the public API.

Future versions may add route batches, calendar-style searches, or dedicated summary outputs if user demand supports them.

# Actor input Schema

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

Three-letter IATA origin airport code, for example JFK, LAX, SFO, or ORD.

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

Three-letter IATA destination airport code, for example LHR, CDG, NRT, or HND.

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

Travel date to search in YYYY-MM-DD format.

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

Maximum number of itinerary-level award-flight results to save.

## `deltaDays` (type: `integer`):

Ask Flightpoints to search nearby dates. Keep this low for faster and cheaper runs.

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

Filter returned itineraries to a cabin class where supported by Flightpoints.

## `minimumSeats` (type: `integer`):

Minimum available award seats. Use 1 for broad monitoring; increase for family/group trips.

## `onlyDirectFlights` (type: `boolean`):

Return only non-stop itineraries when Flightpoints has that filter available.

## `maxTaxesUsd` (type: `integer`):

Optional maximum cash taxes/fees filter in USD-like source units. Leave empty for no fee cap.

## `programs` (type: `array`):

Optional loyalty program codes to include, for example AA, AC, BA, UA, VS. Leave empty for all programs.

## `includeSegments` (type: `boolean`):

Include per-segment connection details in each output item.

## `liveSearch` (type: `boolean`):

Ask Flightpoints for a live refresh instead of cached availability when available. Cached mode is faster and recommended for monitoring.

## `pollTimeoutSecs` (type: `integer`):

Maximum time to wait for Flightpoints to finish generating results.

## Actor input object example

```json
{
  "origin": "JFK",
  "destination": "LHR",
  "departureDate": "2026-07-15",
  "maxResults": 20,
  "deltaDays": 0,
  "cabinClass": "Any",
  "minimumSeats": 1,
  "onlyDirectFlights": false,
  "programs": [],
  "includeSegments": true,
  "liveSearch": false,
  "pollTimeoutSecs": 20
}
```

# Actor output Schema

## `awardFlights` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "origin": "JFK",
    "destination": "LHR",
    "departureDate": "2026-07-15",
    "maxResults": 20,
    "deltaDays": 0,
    "cabinClass": "Any",
    "minimumSeats": 1,
    "onlyDirectFlights": false,
    "programs": [],
    "includeSegments": true,
    "liveSearch": false,
    "pollTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flightpoints-award-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": "LHR",
    "departureDate": "2026-07-15",
    "maxResults": 20,
    "deltaDays": 0,
    "cabinClass": "Any",
    "minimumSeats": 1,
    "onlyDirectFlights": False,
    "programs": [],
    "includeSegments": True,
    "liveSearch": False,
    "pollTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flightpoints-award-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": "LHR",
  "departureDate": "2026-07-15",
  "maxResults": 20,
  "deltaDays": 0,
  "cabinClass": "Any",
  "minimumSeats": 1,
  "onlyDirectFlights": false,
  "programs": [],
  "includeSegments": true,
  "liveSearch": false,
  "pollTimeoutSecs": 20
}' |
apify call automation-lab/flightpoints-award-flights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flightpoints Award Flights Scraper",
        "description": "✈️ Scrape Flightpoints award-seat availability with miles, taxes, cabins, seats, programs, segments, and booking URLs.",
        "version": "0.1",
        "x-build-id": "QlgPZP3WZthhh6mE2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~flightpoints-award-flights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-flightpoints-award-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/automation-lab~flightpoints-award-flights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-flightpoints-award-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/automation-lab~flightpoints-award-flights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-flightpoints-award-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": [
                    "origin",
                    "destination",
                    "departureDate"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin airport",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "Three-letter IATA origin airport code, for example JFK, LAX, SFO, or ORD."
                    },
                    "destination": {
                        "title": "Destination airport",
                        "minLength": 3,
                        "maxLength": 3,
                        "type": "string",
                        "description": "Three-letter IATA destination airport code, for example LHR, CDG, NRT, or HND."
                    },
                    "departureDate": {
                        "title": "Departure date",
                        "type": "string",
                        "description": "Travel date to search in YYYY-MM-DD format."
                    },
                    "maxResults": {
                        "title": "Maximum itineraries",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of itinerary-level award-flight results to save.",
                        "default": 20
                    },
                    "deltaDays": {
                        "title": "Date flexibility (+/- days)",
                        "minimum": 0,
                        "maximum": 14,
                        "type": "integer",
                        "description": "Ask Flightpoints to search nearby dates. Keep this low for faster and cheaper runs.",
                        "default": 0
                    },
                    "cabinClass": {
                        "title": "Cabin filter",
                        "enum": [
                            "Any",
                            "Economy",
                            "Premium Economy",
                            "Business",
                            "First"
                        ],
                        "type": "string",
                        "description": "Filter returned itineraries to a cabin class where supported by Flightpoints.",
                        "default": "Any"
                    },
                    "minimumSeats": {
                        "title": "Minimum seats",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum available award seats. Use 1 for broad monitoring; increase for family/group trips.",
                        "default": 1
                    },
                    "onlyDirectFlights": {
                        "title": "Direct flights only",
                        "type": "boolean",
                        "description": "Return only non-stop itineraries when Flightpoints has that filter available.",
                        "default": false
                    },
                    "maxTaxesUsd": {
                        "title": "Maximum taxes / fees",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional maximum cash taxes/fees filter in USD-like source units. Leave empty for no fee cap."
                    },
                    "programs": {
                        "title": "Loyalty programs",
                        "type": "array",
                        "description": "Optional loyalty program codes to include, for example AA, AC, BA, UA, VS. Leave empty for all programs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeSegments": {
                        "title": "Include segment details",
                        "type": "boolean",
                        "description": "Include per-segment connection details in each output item.",
                        "default": true
                    },
                    "liveSearch": {
                        "title": "Request live search",
                        "type": "boolean",
                        "description": "Ask Flightpoints for a live refresh instead of cached availability when available. Cached mode is faster and recommended for monitoring.",
                        "default": false
                    },
                    "pollTimeoutSecs": {
                        "title": "Search polling timeout",
                        "minimum": 10,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum time to wait for Flightpoints to finish generating results.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
