# Momondo Scraper | Flight Prices and Travel Deals (`parseforge/momondo-scraper`) Actor

Search Momondo for flights with origin, destination, dates, airlines, stops, layovers, duration, and prices in any currency. Compare deals across providers, track fares, and find the cheapest tickets for travel apps, price alerts, and trip planning automations worldwide.

- **URL**: https://apify.com/parseforge/momondo-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, E-commerce, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ✈️ Momondo Flight Scraper

> 🚀 **Export flight search results from Momondo to CSV, Excel, JSON, or XML in seconds.** No account needed. No API key required.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **Up to 1,000,000 results** · **Global routes**

Momondo (powered by Kayak) is one of the world's most comprehensive flight comparison engines, aggregating prices from hundreds of airlines and booking platforms. This Actor searches any route and travel date using Playwright to intercept Kayak's real-time poll API, extracting flight results with airline names, departure and arrival times, stop counts, prices, and direct booking links.

Data is fetched live by intercepting API poll responses during a real browser session. Every run produces fresh, real-time pricing for your requested route and date.

**Coverage:** Any origin-destination pair using IATA airport codes (JFK, LHR, CDG, DXB, NRT, etc.) for any date. Each record includes the airline logo, airline name, origin, destination, departure time, arrival time, flight duration, stop count, price, currency, and a deep link to book the flight.

### 🎯 Target Audience / Use Cases

| Who uses this | What they do with it |
|---|---|
| Frequent travelers | Compare prices across airlines for upcoming routes |
| Corporate travel managers | Monitor flight costs for recurring business routes |
| Travel agencies | Research pricing for client itineraries and packages |
| Price tracking developers | Build flight deal alert tools and price history trackers |
| Market researchers | Analyze airline pricing strategies and route competitiveness |
| Budget travelers | Find the cheapest flights for flexible travel dates |

### 📋 What the Momondo Flight Scraper does

- Launches a real browser session and navigates to the Kayak/Momondo search URL
- Intercepts live poll API responses as flight data loads
- Deduplicates results and sorts by lowest price
- Extracts airline name, logo, departure/arrival times, duration, and stop count
- Generates direct deep links to the booking page for each flight option
- Delivers a clean structured dataset: one record per flight option

> 💡 **Why it matters:** Flight prices change constantly and differ by route, airline, and time of search. There is no free public API for real-time flight prices. This Actor automates the browser search session to capture live pricing data that would otherwise require manual searching on multiple platforms.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

<table>
  <thead>
    <tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr>
  </thead>
  <tbody>
    <tr><td><b>origin</b></td><td>string</td><td>Yes</td><td>JFK</td><td>Origin airport IATA code (e.g. JFK, LHR, CDG, DXB)</td></tr>
    <tr><td><b>destination</b></td><td>string</td><td>Yes</td><td>LHR</td><td>Destination airport IATA code (e.g. LHR, JFK, CDG, NRT)</td></tr>
    <tr><td><b>outboundDate</b></td><td>string</td><td>Yes</td><td>2026-08-01</td><td>Travel date in YYYY-MM-DD format</td></tr>
    <tr><td><b>maxItems</b></td><td>integer</td><td>No</td><td>10</td><td>Max flights to return. Free: 10. Paid: up to 1,000,000.</td></tr>
  </tbody>
</table>

**Example 1 - New York to London:**
```json
{
  "origin": "JFK",
  "destination": "LHR",
  "outboundDate": "2026-08-01",
  "maxItems": 25
}
````

**Example 2 - Paris to Dubai:**

```json
{
  "origin": "CDG",
  "destination": "DXB",
  "outboundDate": "2026-09-15",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Use standard IATA airport codes (3 letters). The Actor waits up to 30 seconds for poll responses to populate. Results are sorted by lowest price. Each record includes a deep link to Kayak/Momondo to complete the booking.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ imageUrl | string | Airline logo URL |
| ✈️ airline | string | Airline name (e.g. "American Airlines", "British Airways") |
| 🛫 origin | string | Departure airport IATA code |
| 🛬 destination | string | Arrival airport IATA code |
| 🕐 departureTime | string | Departure datetime (ISO format) |
| 🕓 arrivalTime | string | Arrival datetime (ISO format) |
| ⏱️ duration | string | Total flight duration (e.g. "7h 15m") |
| 🔁 stops | number | Number of stops (0 = nonstop) |
| 💰 price | number | Total price (numeric) |
| 💱 currency | string | Currency code (e.g. USD) |
| 🔗 deepLink | string | Direct link to book this flight on Kayak/Momondo |
| 🕒 scrapedAt | string | ISO timestamp when this record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://www.kayak.com/rimg/provider-logos/airlines/v/AA.png",
  "airline": "American Airlines",
  "origin": "JFK",
  "destination": "LHR",
  "departureTime": "2026-08-01T18:30:00",
  "arrivalTime": "2026-08-02T06:45:00",
  "duration": "7h 15m",
  "stops": 0,
  "price": 487,
  "currency": "USD",
  "deepLink": "https://www.kayak.com/flights/JFK-LHR/2026-08-01?sort=bestflight_a",
  "scrapedAt": "2026-05-22T09:15:00.000Z"
}
```

### ✨ Why choose this Actor

- 🌍 **Any global route** - any IATA origin and destination pair
- 💰 **Sorted by price** - cheapest flights always first
- ✈️ **Airline logos** - visual identification for every result
- ⏱️ **Flight durations** - formatted as "7h 15m" for easy reading
- 🔁 **Stop count** - instantly identify nonstop vs connecting flights
- 🔗 **Direct booking links** - deep links take you straight to the booking page
- 📅 **Date-accurate pricing** - real-time prices for your specific travel date

### 📈 How it compares to alternatives

| Feature | This Actor | Manual search | Flight APIs (paid) |
|---|---|---|---|
| Any global route | Yes | Yes (tedious) | Yes |
| Live pricing | Yes | Yes | Yes |
| Stop count | Yes | Yes | Yes |
| Duration | Yes | Yes | Yes |
| Airline logos | Yes | Yes | Sometimes |
| Booking deep links | Yes | Yes | Rarely |
| Export to CSV/Excel | Yes | No | Requires dev work |
| No API subscription | Yes | Yes | No |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Momondo Flight Scraper on Apify Store
3. Enter origin airport code, destination airport code, and travel date
4. Set `maxItems` (free users get 10 items automatically)
5. Click **Save & Run**
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Corporate travel management

Monitor flight costs for recurring business routes. Build a database of historical prices for budget planning and travel policy benchmarking.

#### Travel agency pricing research

Quickly pull the top flight options for any client route and date. Export to Excel to include in travel proposals and itineraries.

#### Price tracking and deal alerts

Schedule recurring runs for routes you monitor. Compare prices across runs to detect drops and alert travelers or colleagues.

#### Airline and route market analysis

Analyze competitive pricing on specific routes. Which airlines dominate JFK-LHR? What is the average price spread between nonstop and connecting flights?

### 🔌 Automating Momondo Flight Scraper

- **Make (formerly Integromat)** - schedule daily price checks and push to Google Sheets
- **Zapier** - alert your Slack channel when prices drop below a threshold
- **Apify Scheduler** - run automatic weekly route price snapshots
- **REST API** - trigger runs from your travel booking platform
- **Webhooks** - push price data directly to your pricing engine or dashboard

### 🌟 Beyond business use cases

#### Personal travel hacking

Track prices for upcoming trips. Run the scraper weekly as your travel date approaches to catch fare drops.

#### Academic research

Study airline pricing behavior, yield management patterns, or the economics of route competition.

#### Journalism

Investigate airline price gouging during peak travel periods or the pricing disparity between hubs and regional airports.

#### Family trip planning

Pull all options for a family vacation in one clean dataset. Share the spreadsheet with your family to vote on flights.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant questions like:

- "What fields does the Momondo Flight Scraper return?"
- "How do I find nonstop flights only?"
- "What IATA code does JFK use?"
- "Can I track prices for the same route over multiple weeks?"

### ❓ Frequently Asked Questions

**Q: What is an IATA airport code?**
A: A 3-letter code that identifies airports internationally. Examples: JFK (New York JFK), LHR (London Heathrow), CDG (Paris Charles de Gaulle), DXB (Dubai), NRT (Tokyo Narita).

**Q: Can I filter for nonstop flights only?**
A: The Actor returns all available flights sorted by price. You can filter by the `stops` field (0 = nonstop) after downloading the dataset.

**Q: How current are the prices?**
A: Prices are live at the moment of the run. Flight prices change frequently - run again to get updated prices.

**Q: What does the `deepLink` field contain?**
A: A URL that takes you directly to the Kayak/Momondo booking page for that specific flight result.

**Q: Can I search round-trip flights?**
A: The current Actor searches one-way (outbound) flights. Contact ParseForge for round-trip support.

**Q: Why does the Actor use a browser?**
A: Momondo/Kayak's pricing data loads via JavaScript after the page renders. A headless browser is required to intercept the real-time poll API responses.

**Q: How many results can I get?**
A: Free users get up to 10. Paid users can get up to 1,000,000 (subject to the number of flight options Kayak returns for the route).

**Q: Is this data from Momondo or Kayak?**
A: Momondo and Kayak share the same infrastructure (both owned by the same company). The Actor searches Kayak's URL which powers both platforms.

**Q: How long does a run take?**
A: Typically 30-60 seconds. The Actor waits up to 30 seconds for poll responses to load before processing.

**Q: Can I get flights for multiple dates at once?**
A: Each run searches one date. Use the Apify API to trigger parallel runs for multiple dates simultaneously.

### 🔌 Integrate with any app

Export your flight dataset to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable\
**Databases:** PostgreSQL, MySQL, MongoDB, Snowflake\
**BI tools:** Tableau, Power BI, Looker, Metabase\
**Automation:** Make, Zapier, n8n, Pipedream\
**Storage:** AWS S3, Google Cloud Storage, Azure Blob\
**Notifications:** Slack, Discord, email via webhook

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Airbnb Scraper](https://apify.com/parseforge/airbnb-scraper) | Scrape vacation rental listings from Airbnb for any destination |
| [TripAdvisor Hotels Scraper](https://apify.com/parseforge/tripadvisor-scraper) | Scrape hotel listings, ratings, and prices from TripAdvisor |
| [OpenTable Scraper](https://apify.com/parseforge/opentable-scraper) | Export restaurant listings and reservations from OpenTable |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ ready-to-use data scrapers across real estate, jobs, travel, finance, and more.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or associated with Momondo, Kayak, or Booking Holdings. Use of this tool must comply with the applicable Terms of Use and applicable laws. The data collected is publicly available. ParseForge is not responsible for how collected data is used.

# Actor input Schema

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

Origin airport IATA code (e.g. JFK, LHR, CDG)

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

Destination airport IATA code (e.g. LHR, JFK, CDG)

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

Outbound flight date in YYYY-MM-DD format

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "origin": "JFK",
  "destination": "LHR",
  "outboundDate": "2026-08-01",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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",
    "outboundDate": "2026-08-01",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/momondo-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",
    "outboundDate": "2026-08-01",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/momondo-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",
  "outboundDate": "2026-08-01",
  "maxItems": 10
}' |
apify call parseforge/momondo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Momondo Scraper | Flight Prices and Travel Deals",
        "description": "Search Momondo for flights with origin, destination, dates, airlines, stops, layovers, duration, and prices in any currency. Compare deals across providers, track fares, and find the cheapest tickets for travel apps, price alerts, and trip planning automations worldwide.",
        "version": "0.1",
        "x-build-id": "ggr4cnzN2PndynQk6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~momondo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-momondo-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/parseforge~momondo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-momondo-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/parseforge~momondo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-momondo-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",
                    "outboundDate"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin Airport",
                        "type": "string",
                        "description": "Origin airport IATA code (e.g. JFK, LHR, CDG)"
                    },
                    "destination": {
                        "title": "Destination Airport",
                        "type": "string",
                        "description": "Destination airport IATA code (e.g. LHR, JFK, CDG)"
                    },
                    "outboundDate": {
                        "title": "Outbound Date",
                        "type": "string",
                        "description": "Outbound flight date in YYYY-MM-DD format"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
