# Momondo Flights Scraper — $0.70/1K rows, fares & sellers (`lergassy/momondo-flights-scraper`) Actor

Scrape flight prices from Momondo by route and dates: price per booking provider, airline, flight numbers, times, duration, stops and layovers, aircraft and a direct booking link. One-way and round trip, batch routes, all cabins.

- **URL**: https://apify.com/lergassy/momondo-flights-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Travel, Agents
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 rows

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Momondo Flights Scraper

**Momondo Flights Scraper** turns a Momondo flight search into clean rows: the price, **who is selling the ticket** — airline or agency — the airline and flight numbers, times, duration, stops and layover airports, aircraft type, cabin, and a **direct booking link**. One-way and round trip, any cabin, many routes in one run.

**$0.70 per 1,000 rows. No run fee, no page fee, no proxy fee. Error rows are always free.**

Momondo is a metasearch engine, so a row here answers a question Google Flights cannot: *which seller is cheapest for this exact itinerary right now*, with the link that takes you to that price.

### What you get

| Field | Example |
|---|---|
| `price` / `currency` / `priceLabel` | 78 / USD / $78 — round trips are the total for both directions |
| `provider` / `providerCode` | Booking.com / BDCFlight — the seller behind that price |
| `providersForThisFlight` | 5 — how many sellers offer this same itinerary |
| `airline` / `airlines` / `flightNumbers` | Jetstar / \["Jetstar"] / \["JQ86"] |
| `stops` / `layovers[]` | 1 / \[{ "airport": "KUL", "minutes": 95 }] |
| `departAt` / `arriveAt` / `durationMinutes` | 2027-03-15T14:55 / 2027-03-15T18:00 / 185 |
| `legs[]` → `segments[]` | Per flight: airline, flight number, airports, times, duration, aircraft (Airbus A321neo), layover |
| `cabinClass` / `tripType` | economy / round\_trip |
| `bookingUrl` | Deep link straight to that seller's checkout |
| `kayakUrl` | The itinerary's page on Momondo |

Switch on **One row per booking provider** and every seller of an itinerary becomes its own row — that is the comparison table behind "who sells this flight cheapest".

### How to run it

1. Enter **origin** and **destination** as IATA codes (`DPS`, `JFK`, `LHR`) and a **departure date**.
2. Add a **return date** for a round trip, set passengers and cabin.
3. Click **Start**. Rows appear in the **Flights** table.

#### Many routes in one run

```json
{
  "routes": [
    { "origin": "JFK", "destination": "LHR", "departureDate": "2027-03-15", "returnDate": "2027-03-22" },
    { "origin": "JFK", "destination": "CDG", "departureDate": "2027-03-15" },
    { "origin": "BOS", "destination": "LHR", "departureDate": "2027-03-16" }
  ],
  "maxResults": 50
}
```

There is no fee per search, so the number of routes only affects the rows you keep.

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lergassy/momondo-flights-scraper").call(run_input={
    "origin": "JFK", "destination": "LHR",
    "departureDate": "2027-03-15", "returnDate": "2027-03-22",
    "sortBy": "price", "maxResults": 50,
})
for f in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f["price"], f["currency"], f["provider"], f["airline"], f["flightNumbers"])
```

### Bulk export: what it costs

One event, $0.0007 per row — **$0.70 per 1,000 rows**, down to $0.50 per 1,000 on higher Store tiers. Nothing is charged for runs, searches, retries, pages or proxy traffic, and rows that fail are never charged.

| Job | Rows | Cost |
|---|---|---|
| One route, one date | 50 | $0.035 |
| 100 routes swept once | 5,000 | $3.50 |
| 20 routes tracked daily for a month | 30,000 | $21.00 |
| Big export | 50,000 | **$35.00** |

Measured on public pricing on 21 September 2026: the most-used Momondo Actor on Apify charges $0.002 per row, which makes the same 50,000-row job **$100**; the next ones ask $0.01 and $0.021 per row. Some Actors in this category also bill Apify platform usage (compute and proxy) to your own account on top of their row price — here compute and proxy are included.

### What it is good for

- **Fare comparison and metasearch**: the same itinerary from five sellers, with each price and link.
- **Price monitoring**: schedule the routes you care about and store one row per run; `provider` tells you who moved.
- **Travel agencies**: check whether an agency undercuts the airline before you quote a client.
- **Market research**: which carriers and sellers hold which routes, at what price and stop count.

### Inputs

| Input | Notes |
|---|---|
| `origin` / `destination` / `departureDate` / `returnDate` | IATA codes and ISO dates; a return date prices the round trip as one total |
| `adults` / `children` | Up to 9 passengers |
| `cabinClass` | economy, premium economy, business, first |
| `sortBy` | best (Momondo ranking), cheapest, shortest |
| `maxStops` | Nonstop only, or up to one or two stops |
| `maxResults` | Rows per search; Momondo serves 50 per page and more pages are loaded as needed |
| `allProviders` | One row per seller instead of one row per itinerary |
| `currency` | Three-letter code |
| `routes[]` | Many routes in one run |
| `proxyConfiguration` | Default works; switch to residential if a route gets a bot check |

### Notes and limits

Times are local to each airport, as Momondo displays them. Round-trip prices are the total for both directions. Prices move during the day and between sellers — for monitoring, schedule the run rather than caching a result. If Momondo serves a bot check for the IP, the run writes an `error` row that says so and suggests switching the proxy to residential; that row is free.

The Actor reads publicly displayed prices and schedules without logging in, bypassing access controls or collecting personal data. Momondo's terms restrict automated access, and the legality of scraping public data depends on your jurisdiction and use; review the terms and consult a lawyer for commercial use.

### Need a field that isn't here?

**Open an issue on this Actor's page** — answered the same day, most requests shipped within a week.

Related: [Kayak Flights Scraper](https://apify.com/lergassy/kayak-flights-scraper) — the same engine on KAYAK, whose partner mix differs, [Flight Price Comparison](https://apify.com/lergassy/flight-price-comparison) — Google Flights against KAYAK in one run.

# Actor input Schema

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

Departure airport code, e.g. <code>DPS</code> (Bali), <code>JFK</code> (New York), <code>LHR</code> (London)

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

Arrival airport code, e.g. <code>SIN</code> (Singapore), <code>BKK</code> (Bangkok)

## `site` (type: `string`):

Which metasearch to read. KAYAK and Momondo are the same engine with different partner mixes, so prices can differ.

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

Format <code>YYYY-MM-DD</code>. Leave the route empty and the Actor runs a demo search, so a first run always returns rows.

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

Format <code>YYYY-MM-DD</code>. Leave empty for a one-way search. Round-trip prices are the total for both directions.

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

Number of adult passengers

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

Passengers aged 2–11

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

Fare class to search

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

How KAYAK orders the results before they are read

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

KAYAK returns 50 per page; more pages are loaded until this many rows are collected

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

Drop itineraries with more stops than this

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

Three-letter code, e.g. <code>USD</code>, <code>EUR</code>, <code>GBP</code>

## `allProviders` (type: `boolean`):

Off: one row per itinerary with the cheapest provider. On: one row for every provider selling that itinerary (agency, airline) with its own price and link.

## `routes` (type: `array`):

Search many routes in one run. Each item: <code>{"origin": "DPS", "destination": "BKK", "departureDate": "2027-03-15", "returnDate": "2027-03-22"}</code>

## `proxyConfiguration` (type: `object`):

Proxy used to reach KAYAK. The default works; residential helps on hard routes.

## Actor input object example

```json
{
  "origin": "DPS",
  "destination": "SIN",
  "site": "momondo",
  "departureDate": "2027-03-15",
  "adults": 1,
  "children": 0,
  "cabinClass": "economy",
  "sortBy": "best",
  "maxResults": 50,
  "maxStops": "any",
  "currency": "USD",
  "allProviders": false,
  "routes": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `flights` (type: `string`):

One row per itinerary — price, the seller behind it, airline and flight numbers, times, duration, stops and layovers, aircraft, cabin and a direct booking link. With 'one row per booking provider' on, every seller of an itinerary gets its own row.

# 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": "DPS",
    "destination": "SIN",
    "departureDate": "2027-03-15",
    "routes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/momondo-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": "DPS",
    "destination": "SIN",
    "departureDate": "2027-03-15",
    "routes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/momondo-flights-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": "DPS",
  "destination": "SIN",
  "departureDate": "2027-03-15",
  "routes": []
}' |
apify call lergassy/momondo-flights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/momondo-flights-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/T12cHr07djO4jUaxj/builds/z0CgNtpFS9ybhe70v/openapi.json