# Flight Price Scraper (`silentflow/flight-price-scraper`) Actor

Search live flight prices by route and date across Google Flights, Kiwi and Ryanair, merged into one result per flight. Get per-source pricing, cheapest source, airlines, times, stops, duration and booking links. Round trips, flexible dates, cabin class. No login, export to JSON, CSV or Excel.

- **URL**: https://apify.com/silentflow/flight-price-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Travel, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Flight Price Scraper

**Compare real flight prices across Kiwi, Ryanair and Google Flights in one call. The same flight, priced by three sources side by side, with direct booking links. Most searches finish in under 2 seconds.**

Stop running one scraper per site and stitching the results together yourself. This actor queries three flight data sources at once, merges the same physical flight into a single row, and shows you which source is cheapest, so you always see the real lowest price and where to book it.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/r3TsprXTWM7BBRKAD/records/how-it-works-v1.png)

### ✨ Why teams choose this over other flight scrapers

Running flight scrapers that fail half the time? Getting one price per flight when three sources disagree by 20%? Paying for a browser to render a page that has an API behind it?

- 🔀 **Three sources in one call, not one.** Kiwi (a metasearch covering 700+ airlines including majors and low-cost carriers), Ryanair direct, and Google Flights. The same flight is priced by every source that has it, so you see the real spread. In testing, Dublin to London Stansted returned the FR290 flight at 16.99 on Ryanair, 18 on Kiwi and 17 on Google Flights, all in one row.
- 🎯 **The cheapest source is picked for you.** Every merged flight has a `bestPrice`, a `cheapestSource`, and a `prices` map so you can see all three and book the lowest. No manual comparison.
- ⚡ **No browser, so it is fast and it does not break.** Pure API and server-rendered data. A three-source search typically returns in 1 to 2 seconds. Browser-based scrapers are slower and fail when a page layout shifts.
- 🛫 **Majors and low-cost carriers together.** Kiwi surfaces low-cost and self-transfer combinations, Google Flights brings the major network carriers (British Airways, Iberia, Lufthansa, Air France and more). You get both in the same result set.
- 🧭 **Filters applied on the server, not after.** Set `maxStops`, `maxPrice`, `nonstopOnly` or `preferredAirlines` and get back only what matches. No post-processing, no throwing away rows you paid to receive.
- 📅 **Flexible-date price calendar.** Set `flexDays` to search a range around your date and get the cheapest fare per day, so you can move a trip a day to save.
- 🔗 **Direct booking links per source.** Every itinerary ships with the link to book it, on Kiwi, on Ryanair, or on Google Flights.
- 🧳 **Deep itinerary detail.** Segments, layovers, self-transfer flags, cabin class, flight numbers and baggage, not just a price and a time.
- 🌍 **Any route, any currency.** Airport or metro codes worldwide, prices in the ISO currency you ask for.
- 🔓 **No login, no API key, no setup.** Type a route and run it.

### 🎯 What you can do with flight data

| Team | What they build |
|---|---|
| Fare-alert and deal apps | Track a route daily and push a notification when the best price drops below a threshold |
| OTA and travel startups | Power a metasearch results page without signing eight airline contracts |
| Corporate travel | Check the real lowest fare on a route before approving a booking, across three sources |
| Travel content and blogs | Build "cheapest month to fly" and "cheapest day" tables from the flexible-date calendar |
| Data and pricing analysts | Compare how Kiwi, Ryanair and Google price the same seat, and track the spread over time |
| Revenue and competitive teams | Monitor a competitor route's public fares and stops over weeks |
| Affiliate and cashback sites | Show live fares with booking links and earn on the click through |

### 📥 Input parameters

#### Route and dates

| Field | Type | Description |
|---|---|---|
| `origin` | string | Departure IATA code (e.g. `LHR`, `JFK`, `LON`). Required. |
| `destination` | string | Arrival IATA code (e.g. `BCN`, `CDG`, `NYC`). Required. |
| `departDate` | string | Outbound date, `YYYY-MM-DD`. Required. |
| `returnDate` | string | Inbound date for round trips, `YYYY-MM-DD`. Optional. |
| `flexDays` | integer | Search this many days before and after each date for a cheapest-per-day calendar. 0 to 7. Default 0. |

#### Passengers and cabin

| Field | Type | Description |
|---|---|---|
| `adults` | integer | Adult passengers, 1 to 9. Default 1. |
| `children` | integer | Child passengers, 0 to 9. Default 0. |
| `infants` | integer | Infant passengers, 0 to 9. Default 0. |
| `cabinClass` | string | `ECONOMY`, `PREMIUM_ECONOMY`, `BUSINESS` or `FIRST`. Default `ECONOMY`. |
| `currency` | string | ISO currency code for prices. Default `USD`. |

#### Filters and output

| Field | Type | Description |
|---|---|---|
| `maxStops` | integer | Maximum stops, 0 to 3. Leave empty for any. |
| `maxPrice` | integer | Only return itineraries at or below this price, in the chosen currency. |
| `nonstopOnly` | boolean | Return only direct flights. Default false. |
| `preferredAirlines` | array | Keep only flights operated by these IATA carrier codes (e.g. `FR`, `VY`, `BA`). |
| `sources` | array | Which sources to query: `kiwi`, `ryanair`, `googleFlights`. Default all three. |
| `maxItems` | integer | Maximum number of itineraries to return. Default 50. |

### 📊 Output data

Every itinerary is one dataset item. A flight found by more than one source is merged into a single row with a `prices` map.

#### A flight priced by three sources

```json
{
  "id": "kiwi-...",
  "from": { "airport": "DUB", "name": "Dublin", "city": "Dublin", "country": "Ireland" },
  "to": { "airport": "STN", "name": "London Stansted", "city": "London", "country": "United Kingdom" },
  "departTime": "2026-08-15T18:00:00",
  "arriveTime": "2026-08-15T19:20:00",
  "durationMinutes": 80,
  "durationText": "1h 20m",
  "stops": 0,
  "nonstop": true,
  "airlines": [{ "code": "FR", "name": "Ryanair" }],
  "primaryAirline": "FR",
  "cabinClass": "ECONOMY",
  "segments": [
    {
      "from": { "airport": "DUB" },
      "to": { "airport": "STN" },
      "departTime": "2026-08-15T18:00:00",
      "arriveTime": "2026-08-15T19:20:00",
      "carrier": { "code": "FR", "name": "Ryanair" },
      "flightNumber": "FR290",
      "durationMinutes": 80
    }
  ],
  "layovers": [],
  "baggage": { "personalItem": 0, "handBag": 0, "checkedBag": 0 },
  "isSelfTransfer": false,
  "price": 16.99,
  "currency": "EUR",
  "prices": { "ryanair": 16.99, "kiwi": 18, "googleFlights": 17 },
  "bestPrice": 16.99,
  "cheapestSource": "ryanair",
  "sources": ["googleFlights", "kiwi", "ryanair"],
  "bookingLinks": {
    "ryanair": "https://www.ryanair.com/gb/en/trip/flights/select?...",
    "kiwi": "https://www.kiwi.com/en/booking/?...",
    "googleFlights": "https://www.google.com/travel/flights/search?tfs=..."
  },
  "date": "2026-08-15",
  "scrapedAt": "2026-07-05T09:00:00Z"
}
````

#### A self-transfer combination from Kiwi

```json
{
  "id": "kiwi-...",
  "from": { "airport": "LHR", "name": "Heathrow" },
  "to": { "airport": "BCN", "name": "Barcelona" },
  "departTime": "2026-08-15T22:25:00",
  "arriveTime": "2026-08-16T09:40:00",
  "durationMinutes": 615,
  "durationText": "10h 15m",
  "stops": 1,
  "nonstop": false,
  "airlines": [{ "code": "EI", "name": "Aer Lingus" }, { "code": "FR", "name": "Ryanair" }],
  "primaryAirline": "EI",
  "segments": [ { "carrier": { "code": "EI" }, "flightNumber": "EI..." }, { "carrier": { "code": "FR" }, "flightNumber": "FR..." } ],
  "layovers": [ { "station": "DUB", "durationMinutes": 120, "selfTransfer": true } ],
  "isSelfTransfer": true,
  "price": 115,
  "currency": "EUR",
  "prices": { "kiwi": 115 },
  "bestPrice": 115,
  "cheapestSource": "kiwi",
  "sources": ["kiwi"],
  "bookingLinks": { "kiwi": "https://www.kiwi.com/en/booking/?..." },
  "scrapedAt": "2026-07-05T09:00:00Z"
}
```

### 🗂️ Data fields

| Category | Fields |
|---|---|
| Route | `from`, `to` (each with `airport`, `name`, `city`, `country`) |
| Schedule | `departTime`, `arriveTime`, `durationMinutes`, `durationText`, `date` |
| Routing | `stops`, `nonstop`, `isSelfTransfer`, `segments`, `layovers` |
| Trip | `tripType` (`oneWay` or `roundTrip`) |
| Return leg (round trips) | `returnDepartTime`, `returnArriveTime`, `returnDurationMinutes`, `returnStops`, `returnSegments`, `returnLayovers` |
| Airlines | `airlines`, `primaryAirline`, `cabinClass`, per-segment `carrier` and `flightNumber` |
| Baggage | `baggage` (`personalItem`, `handBag`, `checkedBag`) |
| Pricing | `price`, `currency`, `prices` (per source), `bestPrice`, `cheapestSource`, `sources` |
| Booking | `bookingLinks` (per source) |
| Meta | `id`, `scrapedAt` |

### 🚀 Examples

**Find the cheapest way to fly London to Barcelona**

```json
{ "origin": "LHR", "destination": "BCN", "departDate": "2026-08-15", "currency": "EUR" }
```

**Round trip in business class for two adults**

```json
{ "origin": "JFK", "destination": "CDG", "departDate": "2026-09-10", "returnDate": "2026-09-17", "adults": 2, "cabinClass": "BUSINESS" }
```

**Direct flights only, under 120 EUR**

```json
{ "origin": "DUB", "destination": "STN", "departDate": "2026-08-15", "nonstopOnly": true, "maxPrice": 120, "currency": "EUR" }
```

**Cheapest day to fly across a week (price calendar)**

```json
{ "origin": "BER", "destination": "LIS", "departDate": "2026-08-15", "flexDays": 7, "currency": "EUR" }
```

**Only Ryanair fares on a route**

```json
{ "origin": "DUB", "destination": "STN", "departDate": "2026-08-15", "preferredAirlines": ["FR"], "sources": ["ryanair", "kiwi"] }
```

### 🤖 Copy to your AI assistant

```
I am using the Flight Price Scraper on Apify. It takes origin, destination and departDate
(YYYY-MM-DD), plus optional returnDate, adults, cabinClass, currency, flexDays, maxStops,
maxPrice, nonstopOnly, preferredAirlines and sources. It returns flight itineraries, each
with a prices map per source (kiwi, ryanair, googleFlights), a bestPrice, a cheapestSource,
segments, layovers, baggage and bookingLinks. Write me an input to find the cheapest nonstop
flight from <ORIGIN> to <DESTINATION> on <DATE>, and explain how to read the prices map to
find the lowest fare and where to book it.
```

### 💻 Integrations

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("silentflow/flight-price-scraper").call(run_input={
    "origin": "LHR",
    "destination": "BCN",
    "departDate": "2026-08-15",
    "currency": "EUR",
    "nonstopOnly": True
})
for it in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(it["bestPrice"], it["currency"], it["primaryAirline"], "via", it["cheapestSource"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('silentflow/flight-price-scraper').call({
    origin: 'JFK',
    destination: 'CDG',
    departDate: '2026-09-10',
    returnDate: '2026-09-17',
    cabinClass: 'BUSINESS',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(f => console.log(f.bestPrice, f.currency, f.cheapestSource, f.bookingLinks));
```

**Daily fare monitor**

Schedule the actor to run each morning on your routes, then compare the new `bestPrice` against yesterday's dataset. When the price drops, send yourself the row's `bookingLinks` so you can book in one click.

### 📈 Performance

| Metric | Value |
|---|---|
| Sources queried per run | Up to 3 (Kiwi, Ryanair, Google Flights) in parallel |
| Typical search time | 1 to 2 seconds |
| Results per search | Dozens of itineraries per route, merged across sources |
| Engine | Pure API and server-rendered data, no browser |
| Reliability | A slow or unavailable source is skipped, the run still returns results from the others |

### 💾 Data export

Results are available as JSON, CSV, Excel, XML and RSS through the Apify dataset, via the API or the Console. Pull them into a sheet, a database or your app with one request.

### 💡 Tips for best results

- **Use airport codes for precision, metro codes for breadth.** `LHR` searches Heathrow only; `LON` searches all London airports. `NYC`, `PAR`, `MIL` and other metro codes are supported too.
- **Read the `prices` map, not just `price`.** The `bestPrice` and `cheapestSource` tell you the lowest fare and where to book it. The full `prices` map shows every source that had the flight.
- **Set `flexDays` to find a cheaper day.** Moving a trip by one or two days often cuts the fare. The `date` field on each row tells you which day it is for.
- **Ryanair returns its cheapest direct fare on a route.** On routes Ryanair does not serve from your origin, it returns nothing, and Kiwi and Google Flights still cover the route.
- **Narrow with filters before you scale.** `nonstopOnly`, `maxStops` and `preferredAirlines` cut the result set to what you actually want, so every returned row is useful.

### ❓ FAQ

**Which sources does it use?** Kiwi (a metasearch that resells 700+ airlines including low-cost and major carriers), Ryanair direct, and Google Flights.

**Do I need a login or API key for the airlines?** No. You only need your Apify token to run the actor. No airline account, no API key.

**How can three sources appear in one row?** When Kiwi, Ryanair and Google Flights all have the same physical flight (same carrier and the same departure and arrival times), the actor merges them into one itinerary and lists each source's price in the `prices` map.

**What if a source is down or slow?** The run still succeeds. Each source has its own timeout and runs independently, so a slow source is skipped and you get results from the others. Kiwi is the broadest source and usually carries the search on its own.

**Does it support round trips?** Yes. Add `returnDate` and each row becomes a round-trip itinerary with `tripType` set to `roundTrip`, the outbound leg in `segments` and the inbound leg in `returnSegments`, priced as one combined round-trip fare.

**Can I search a whole month for the cheapest day?** Use `flexDays` up to 7 to search a window around your date and get the cheapest fare per day.

**Does it return connecting and self-transfer flights?** Yes. Kiwi surfaces connecting and self-transfer combinations. Each row shows `stops`, `layovers` and an `isSelfTransfer` flag so you know when two separate tickets are involved.

**Which currency will prices be in?** The ISO currency you pass in `currency`. Default is USD.

**Can I limit results to specific airlines?** Yes. Pass IATA codes in `preferredAirlines` (for example `["FR", "VY"]`) and only those carriers are returned.

**How many results do I get?** As many as the sources return for your route, up to `maxItems` (default 50), sorted from cheapest to most expensive.

### ⚖️ Legal

This actor collects publicly available flight pricing and schedule information. It does not require or collect any personal data. Use the data in line with the source sites' terms and with applicable regulations such as GDPR and CCPA. You are responsible for how you use the data you collect, particularly for any onward publication or commercial redistribution.

### 🔗 Related scrapers

Building travel and price monitoring tools? Pair this with an accommodation or ground-transport scraper to cover a full trip. Browse the other actors on this account for hotels, vacation rentals and marketplace pricing.

### 📬 Support

Run it, check the output against your route, and adjust the filters to fit your use case. If a route returns fewer results than expected, widen `flexDays` or remove `nonstopOnly` and run again.

# Actor input Schema

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

Departure IATA code (e.g. LHR, JFK, LON).

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

Arrival IATA code (e.g. BCN, CDG, NYC).

## `departDate` (type: `string`):

Outbound date in YYYY-MM-DD format.

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

Optional inbound date for round trips, YYYY-MM-DD.

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

Number of adult passengers.

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

Number of child passengers.

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

Number of infant passengers.

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

Travel class.

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

ISO currency code for prices (e.g. USD, EUR, GBP).

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

Maximum number of itineraries to return.

## `flexDays` (type: `integer`):

Search this many days before and after each date to build a cheapest-per-day price calendar. 0 means exact dates only.

## `maxStops` (type: `integer`):

Maximum number of stops. Leave empty for any.

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

Only return itineraries at or below this price, in the selected currency.

## `nonstopOnly` (type: `boolean`):

Return only direct flights.

## `preferredAirlines` (type: `array`):

Keep only itineraries operated by these carriers (IATA codes, e.g. FR, VY, BA).

## `sources` (type: `array`):

Which price sources to query. Default is all.

## Actor input object example

```json
{
  "origin": "LHR",
  "destination": "BCN",
  "departDate": "2026-08-15",
  "adults": 1,
  "children": 0,
  "infants": 0,
  "cabinClass": "ECONOMY",
  "currency": "USD",
  "maxItems": 50,
  "flexDays": 0,
  "nonstopOnly": false,
  "sources": [
    "kiwi",
    "ryanair",
    "googleFlights"
  ]
}
```

# Actor output Schema

## `itineraries` (type: `string`):

Each item includes: from, to, departTime, arriveTime, durationText, stops, airlines, cabinClass, segments, layovers, baggage, price, currency, prices per source, bestPrice, cheapestSource, sources, bookingLinks and scrapedAt.

# 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": "LHR",
    "destination": "BCN",
    "departDate": "2026-08-15"
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/flight-price-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": "LHR",
    "destination": "BCN",
    "departDate": "2026-08-15",
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/flight-price-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": "LHR",
  "destination": "BCN",
  "departDate": "2026-08-15"
}' |
apify call silentflow/flight-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flight Price Scraper",
        "description": "Search live flight prices by route and date across Google Flights, Kiwi and Ryanair, merged into one result per flight. Get per-source pricing, cheapest source, airlines, times, stops, duration and booking links. Round trips, flexible dates, cabin class. No login, export to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "aONbb2H1fyMAzdRWy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~flight-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-flight-price-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/silentflow~flight-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-flight-price-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/silentflow~flight-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-flight-price-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",
                    "departDate"
                ],
                "properties": {
                    "origin": {
                        "title": "Origin airport",
                        "type": "string",
                        "description": "Departure IATA code (e.g. LHR, JFK, LON)."
                    },
                    "destination": {
                        "title": "Destination airport",
                        "type": "string",
                        "description": "Arrival IATA code (e.g. BCN, CDG, NYC)."
                    },
                    "departDate": {
                        "title": "Departure date",
                        "type": "string",
                        "description": "Outbound date in YYYY-MM-DD format."
                    },
                    "returnDate": {
                        "title": "Return date",
                        "type": "string",
                        "description": "Optional inbound date for round trips, YYYY-MM-DD."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of adult passengers.",
                        "default": 1
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of child passengers.",
                        "default": 0
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Number of infant passengers.",
                        "default": 0
                    },
                    "cabinClass": {
                        "title": "Cabin class",
                        "enum": [
                            "ECONOMY",
                            "PREMIUM_ECONOMY",
                            "BUSINESS",
                            "FIRST"
                        ],
                        "type": "string",
                        "description": "Travel class.",
                        "default": "ECONOMY"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO currency code for prices (e.g. USD, EUR, GBP).",
                        "default": "USD"
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of itineraries to return.",
                        "default": 50
                    },
                    "flexDays": {
                        "title": "Flexible days (+/-)",
                        "minimum": 0,
                        "maximum": 7,
                        "type": "integer",
                        "description": "Search this many days before and after each date to build a cheapest-per-day price calendar. 0 means exact dates only.",
                        "default": 0
                    },
                    "maxStops": {
                        "title": "Max stops",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Maximum number of stops. Leave empty for any."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "type": "integer",
                        "description": "Only return itineraries at or below this price, in the selected currency."
                    },
                    "nonstopOnly": {
                        "title": "Nonstop only",
                        "type": "boolean",
                        "description": "Return only direct flights.",
                        "default": false
                    },
                    "preferredAirlines": {
                        "title": "Preferred airlines",
                        "type": "array",
                        "description": "Keep only itineraries operated by these carriers (IATA codes, e.g. FR, VY, BA).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which price sources to query. Default is all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "kiwi",
                                "ryanair",
                                "googleFlights"
                            ],
                            "enumTitles": [
                                "Kiwi",
                                "Ryanair",
                                "Google Flights"
                            ]
                        },
                        "default": [
                            "kiwi",
                            "ryanair",
                            "googleFlights"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
