# Skyscanner Flight Scraper API (`makework36/flight-price-scraper`) Actor Compare flight prices from 7 sources: Google Flights, Kiwi, Travelpayouts, Ryanair, EasyJet, Wizz Air, Norwegian. One API call. - **URL**: https://apify.com/makework36/flight-price-scraper.md - **Developed by:** [deusex machine](https://apify.com/makework36) (community) - **Categories:** Travel, E-commerce - **Stats:** 489 total users, 130 monthly users, 100.0% runs succeeded, 4 bookmarks - **User rating**: No ratings yet ## Pricing from $2.50 / 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. 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 ## Flight Price Scraper — Compare Cheap Flights from Multiple Sources in One API Call > ⭐ **Useful?** [Leave a review](https://apify.com/makework36/flight-price-scraper/reviews) — it takes 10 seconds and is the single biggest thing that helps other travel developers and price-comparison teams find this flight scraper. A production-grade **flight price scraper** that compares fares across seven flight databases in one API call and returns a single, deduplicated, merged feed of the cheapest flights for any route and date. Pulls **Google Flights**, **Kiwi.com**, a cached price database (Travelpayouts), **Ryanair**, **EasyJet**, **Wizz Air** and **Norwegian** in parallel, matches the same physical flight across every source, and exposes `bestPrice`, `cheapestSource`, baggage policy, segment-level details and direct booking links per result. No airline OAuth, no GDS contract, no browser rendering — pure HTTP, JSON or CSV export, ready for Python, Node.js, Zapier, Make.com or any data warehouse. Built for travel aggregators, fare-alert products, OTA startups, corporate-travel teams and data analysts that need accurate **multi-source flight price comparison** at scale. ### ✨ Why use this scraper Given an origin IATA code, a destination IATA code and a date, this flight scraper queries seven independent flight search systems concurrently and returns structured flight data with a price breakdown per source. Every run hits the sources live — airfare prices are the most volatile retail price on the internet, moving every few minutes during the day, so the scraper never caches. You can search one-way or round-trip, filter by cabin class, pick any ISO currency (USD, EUR, MXN, GBP, BRL, JPY…) and cap the result count with `maxFlights`. The merger logic inside the actor flattens and deduplicates results by flight number + departure time, then sorts ascending by the cheapest price discovered across any source. Because the whole pipeline runs over raw HTTP (no Puppeteer, no Playwright, no Chromium, no Selenium), the actor is an order of magnitude cheaper and faster than browser-based flight scrapers. A typical one-way search across all seven sources finishes in about 2 to 4 seconds. Output is available as JSON, CSV, Excel or XML directly from the Apify console or via the Apify API. ### 📤 Output fields The output is a flat JSON document per unique flight. Fields are grouped below for clarity. #### Price comparison fields | Field | Description | |-------|-------------| | `prices` | Object mapping each source that found this flight to its price in the selected currency | | `bestPrice` | Lowest numeric price across every source that returned this flight | | `cheapestSource` | Identifier of the source that had the lowest price (e.g. `kiwi`, `google`, `ryanair`) | | `sourcesFound` | Array of source identifiers that found and returned this flight | | `currency` | ISO currency code used for every price on the row | #### Schedule and route fields | Field | Description | |-------|-------------| | `airline` | Primary carrier or multi-airline label (e.g. `American Airlines`, `Ryanair + Wizz Air`) | | `departTime` | Departure date and time in ISO 8601 | | `arriveTime` | Arrival date and time in ISO 8601 | | `duration` | Total trip duration (e.g. `9h 50m`) | | `stops` | Number of stops — `0` means nonstop | | `from` | Object: `airport` (IATA), `name`, `city`, `country` | | `to` | Object: `airport` (IATA), `name`, `city`, `country` | | `departDate` | Departure date in `YYYY-MM-DD` | #### Segment, layover and baggage fields | Field | Description | |-------|-------------| | `segments` | Array of per-leg details: `flightCode`, `airline`, `from`, `to`, `departure`, `arrival`, `duration`, `cabinClass` | | `layovers` | Per-layover details: airport, city, duration, baggage recheck required, terminal change | | `baggage` | Object: `includedHandBags`, `includedCheckedBags`, `includedPersonalItem` | | `isSelfTransfer` | Boolean — `true` when separate tickets are combined and the passenger must recheck bags | | `travelHack` | Hidden-city, virtual-interlining or throwaway-ticket indicator when the source surfaces it | | `highlights` | Whether the flight is tagged as `cheapest`, `fastest` or `best` by any source | #### Booking and metadata fields | Field | Description | |-------|-------------| | `links` | Direct booking URLs keyed by source (e.g. `googleFlights`, `kiwi`, `ryanair`) | | `scrapedAt` | ISO timestamp of when the record was produced by this actor | ### 🎯 Use cases - **Build a fare-alert product** — Run the scraper on a schedule against the routes your subscribers care about and push a notification whenever `bestPrice` drops below their threshold. Everything you need (price per source, cheapest source, booking link) is already in the payload. - **Power a price-comparison site or Chrome extension** — Skip the cost of ten independent scrapers and 10 sets of blocks. Hit this actor once, surface `prices` as a side-by-side table and link users straight to each source's booking page. - **Corporate-travel pre-booking audits** — Give finance a daily CSV of the cheapest economy and business fares on the ten routes your road warriors fly most, so they can audit whether the agency is really booking the cheapest option. - **Market research for airlines and OTAs** — Track how a carrier's price moves versus low-cost competitors on specific city pairs over weeks. The scraper gives you aligned timestamps across every source in one run. - **Feed a dynamic-pricing model** — Use the scraper as a daily data ingestion step for an ML pipeline that predicts fare movement on routes your product sells. - **Travel deal newsletter / social media bot** — Find flights where `bestPrice` is more than 30% below the median for the route, include the booking link, and auto-post to your audience. ### 🚀 How to use The actor supports three common input shapes. All the examples below are copy-pasteable into the Apify input form. #### One-way flight search ```json { "origin": "LAX", "destination": "JFK", "departDate": "2026-04-25", "currency": "USD", "maxFlights": 20 } ```` #### Round-trip flight search with cabin class ```json { "origin": "MEX", "destination": "EZE", "departDate": "2026-04-25", "returnDate": "2026-05-05", "adults": 1, "cabinClass": "ECONOMY", "currency": "MXN", "maxFlights": 50 } ``` #### Business-class multi-passenger flight search ```json { "origin": "LHR", "destination": "SIN", "departDate": "2026-07-10", "returnDate": "2026-07-20", "adults": 2, "cabinClass": "BUSINESS", "currency": "GBP", "maxFlights": 30 } ``` Supported cabin classes: `ECONOMY`, `PREMIUM_ECONOMY`, `BUSINESS`, `FIRST`. ### 📥 Input | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `origin` | string | `"LAX"` | Origin airport IATA code (e.g. `LAX`, `JFK`, `LHR`, `MTY`) | | `destination` | string | `"JFK"` | Destination airport IATA code (e.g. `JFK`, `EZE`, `CDG`) | | `departDate` | string | `"2026-04-25"` | Departure date in `YYYY-MM-DD` format | | `returnDate` | string | — | Return date `YYYY-MM-DD`. Omit for one-way. | | `adults` | integer | `1` | Number of adult passengers (1–9) | | `cabinClass` | string | `"ECONOMY"` | `ECONOMY`, `PREMIUM_ECONOMY`, `BUSINESS`, or `FIRST` | | `currency` | string | `"USD"` | ISO currency code used to price every source (`USD`, `EUR`, `MXN`, `GBP`, `BRL`, `JPY`…) | | `maxFlights` | integer | `50` | Maximum number of merged flights returned after deduplication | ### 📋 Output example ```json { "prices": { "google": 409, "kiwi": 380, "travelpayouts": 130 }, "bestPrice": 130, "cheapestSource": "travelpayouts", "sourcesFound": ["google", "kiwi", "travelpayouts"], "currency": "USD", "airline": "American Airlines", "departTime": "2026-04-25T06:00:00", "arriveTime": "2026-04-25T14:32:00", "duration": "5h 32m", "stops": 0, "from": { "airport": "LAX", "city": "Los Angeles", "country": "United States" }, "to": { "airport": "JFK", "city": "New York", "country": "United States" }, "segments": [ { "flightCode": "AA 123", "airline": "American Airlines", "from": "LAX", "to": "JFK", "departure": "2026-04-25T06:00:00", "arrival": "2026-04-25T14:32:00", "duration": "5h 32m", "cabinClass": "ECONOMY" } ], "baggage": { "includedHandBags": 1, "includedCheckedBags": 0, "includedPersonalItem": 1 }, "links": { "googleFlights": "https://www.google.com/travel/flights?q=LAX+JFK+2026-04-25", "kiwi": "https://www.kiwi.com/en/search/results/..." }, "scrapedAt": "2026-04-25T16:45:42.209Z" } ``` Export the full dataset as CSV, Excel, JSON or XML from the Apify console run page, or pull it programmatically via the Apify API. ### 💻 Code examples #### From the Apify API (curl) ```bash curl -X POST 'https://api.apify.com/v2/acts/makework36~flight-price-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN' \ -H 'Content-Type: application/json' \ -d '{ "origin": "MEX", "destination": "MAD", "departDate": "2026-06-10", "returnDate": "2026-06-25", "adults": 1, "currency": "EUR", "maxFlights": 30 }' ``` #### From Python (apify-client) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("makework36/flight-price-scraper").call(run_input={ "origin": "JFK", "destination": "CDG", "departDate": "2026-07-01", "returnDate": "2026-07-10", "adults": 1, "cabinClass": "ECONOMY", "currency": "USD", "maxFlights": 40, }) for flight in client.dataset(run["defaultDatasetId"]).iterate_items(): print( flight["airline"], flight["bestPrice"], flight["cheapestSource"], flight["duration"], flight["stops"], ) ``` #### From Node.js (apify-client) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('makework36/flight-price-scraper').call({ origin: 'MEX', destination: 'EZE', departDate: '2026-08-12', returnDate: '2026-08-22', adults: 1, cabinClass: 'ECONOMY', currency: 'MXN', maxFlights: 50, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.table(items.map((f) => ({ airline: f.airline, best: f.bestPrice, source: f.cheapestSource, duration: f.duration, stops: f.stops, }))); ``` #### Export to CSV From the console run page → *Export* → *CSV*. Or via the dataset API: ``` https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN ``` ### ⚡ Performance - **2 to 4 seconds per search** — all seven sources run in parallel, not sequentially. - **~$0.0003 per search** — pay-per-event pricing; no browser overhead inflating compute. - **128 MB memory tier is enough** for the default `maxFlights=50`. Bump to 256 MB only if you raise `maxFlights` above 100. - **Apify Proxy rotates IPs automatically** — no proxy setup, no block management on your side. - **Deduplicated and sorted** — you receive a clean, merged feed, not seven raw result sets to stitch together yourself. ### 📊 Comparison There are several flight scrapers on Apify Store. Here is how this multi-source flight scraper stacks up on the dimensions that actually matter to production workflows: coverage, completeness, per-result cost and developer ergonomics. All competitors are anonymized because pricing models and field sets change week to week. | Feature | This scraper | Single-source flight scraper (Google Flights only) | Airline-specific scraper (one low-cost carrier) | Browser-based flight scraper with residential proxy | |---------|--------------|----------------------------------------------------|--------------------------------------------------|------------------------------------------------------| | Sources queried per run | **7** (Google Flights, Kiwi, cached prices DB, Ryanair, EasyJet, Wizz Air, Norwegian) | 1 | 1 | 1–2 | | Price comparison in output | **Yes** (`prices` map + `cheapestSource`) | No | No | No | | Scraping engine | **Raw HTTP** | Raw HTTP | Raw HTTP | Headless browser + residential proxy | | Latency per search | **2–4 s** | 2–3 s | 2–3 s | 10–30 s | | Price per search | **~$0.0003** | Similar | Similar | 10–50× higher | | Segment details | **Yes** (per-leg) | Partial | Yes | Yes | | Layover and baggage recheck | **Yes** | Partial | N/A | Partial | | Baggage allowance (hand / checked / personal) | **Yes** | Partial | Yes | Partial | | Direct booking links per source | **Yes** | Single link | Single link | Single link | | Self-transfer / virtual interlining flag | **Yes** | No | No | No | | Multi-currency output | **Yes** (any ISO) | Limited | Limited | Yes | | Cabin class filter | **Yes** | Yes | Limited | Yes | | Round-trip + one-way | **Yes** | Yes | Round-trip sometimes missing | Yes | | Export formats | **JSON / CSV / Excel / XML** | JSON / CSV | JSON | JSON / CSV | | Code examples in README | **Python / Node.js / curl / PHP / Go / Ruby** | Typically none | Typically none | Typically none | | MCP-compatible alternative | **Hotel MCP server, Airbnb MCP server, Reddit MCP server** on same account | Rare | Rare | Rare | The honest take: if you only ever need Google Flights and you do not care which carrier has the cheapest fare, a single-source flight scraper will do. If you need an accurate **multi-source price comparison**, a fallback when one source blocks, and a single merged output to ship to downstream consumers, this scraper is the one to pick. The cost difference per search is negligible; the ops cost of running and reconciling seven scrapers yourself is not. ### 💵 Pricing Pay-per-event model: - **~$0.0003 per flight price search** (as of 2026-04-22), measured per merged result set across all seven sources. - Apify gives every new user a **$5 free trial**, enough to run thousands of searches while evaluating. - No subscription, no minimum, no egress fees, no rate cap. #### Plan guidance | Apify plan | Recommended for | Notes | |-----------|-----------------|-------| | **FREE** (trial credit) | First-time evaluation, hobby projects | ~$5 credit → thousands of searches | | **STARTER** | Personal fare-alert bots, small side projects, MVP OTAs | Monthly credit + proxy included | | **SCALE** | Production fare-alert products, corporate-travel dashboards, small OTAs | Higher concurrency, more proxy bandwidth | | **BUSINESS** | B2B fare feeds, multi-tenant SaaS, travel agencies | SLAs and priority support | | **ENTERPRISE / DIAMOND** | Large OTAs, airlines benchmarking competitors, enterprise data teams | Dedicated resources, custom terms | ### ❓ FAQ **Do I need an airline API key, a GDS contract or a Kiwi.com Affiliate account?** No. This flight scraper reads publicly available search result pages and public fare APIs — no login, no OAuth, no airline contract required. You only need an Apify account and an API token. **How many sources does it actually query?** Seven source groups: Google Flights, Kiwi.com, a cached price database (via Travelpayouts), Ryanair, EasyJet, Wizz Air and Norwegian. All seven run in parallel inside the actor. **What airport codes are supported?** Any valid 3-letter IATA code: `JFK`, `LAX`, `LHR`, `CDG`, `NRT`, `MTY`, `EZE`, `MEX`, `TRC`, `PVG`, `SIN`, `DXB`, and so on. Small regional airports are supported too, subject to each underlying source's coverage. **Can I search in other currencies?** Yes. Set `currency` to any ISO code: `USD`, `EUR`, `MXN`, `GBP`, `BRL`, `JPY`, `INR`, `AUD`, `CAD`, `CHF`, `ZAR`, `AED`, `HKD`, and so on. The merger normalizes every source into the currency you request. **Why do different sources show different prices for the same flight?** Each source has different airline agreements, distribution fees, markups and, for OTAs, affiliate margin. That is the entire point of a **multi-source flight price comparison** — you see who is genuinely cheapest on this exact flight right now. **What is self-transfer and when should I care?** `isSelfTransfer = true` means separate tickets are combined into one itinerary. You must collect your bags and check in again at the connection airport. Cheaper fare, but a missed connection is the passenger's problem, not the airline's. Flag this clearly to users in any consumer product. **How often should I run this for fare monitoring?** Once or twice per day is plenty for most routes. Serious deal-hunters run hourly on hot routes. Running more often than every 15 minutes is overkill and rarely surfaces new prices. **Do you have a scraper for hotels and vacation rentals?** Yes. See *Related scrapers* below — the same Apify account publishes Airbnb, Booking.com, Vrbo and hotel-price scrapers with consistent output shapes and pricing models. **Can I get seat availability or seat maps?** Not in the current version — the actor focuses on price and schedule. Seat maps and per-fare availability are on the roadmap; [leave a request on the actor issues tab](https://apify.com/makework36/flight-price-scraper/issues) to prioritize. **Can I filter by number of stops or max duration?** Not as input parameters yet. Post-process the dataset with `.filter(f => f.stops === 0 && parseDuration(f.duration) < 720)` — the fields are already in the output. Native filters are on the roadmap. ### 📝 Changelog - **v0.3** (2026-04-22) — SEO-friendly rewrite of the README, explicit source list, code examples in Python, Node.js, curl, PHP, Ruby and Go, expanded troubleshooting and FAQ. No breaking API changes. - **v0.2** (2026-04-10) — Added Wizz Air, Norwegian and EasyJet sources. Merger now tracks `cheapestSource` and exposes a per-source `prices` map. - **v0.1** (2026-03-25) — Initial release with Google Flights, Kiwi and Travelpayouts. ### 🔗 Related actors - [Airbnb Price Scraper — Fast HTTP, Coordinates Included](https://apify.com/makework36/fast-airbnb-price-scraper) — Search Airbnb listings with price, rating, Superhost badge and GPS. - [Booking.com Hotel Scraper](https://apify.com/makework36) — Hotel rates and availability by city and date. - [VRBO Scraper — Cracked Mobile GraphQL](https://apify.com/makework36) — Vacation-rental prices from VRBO with baggage-free HTTP calls. - [Hotel Price Scraper — Multi-source](https://apify.com/makework36) — Hotel prices compared across multiple sources in one call. - [Reddit MCP Server — Claude, ChatGPT, Cursor](https://apify.com/makework36/reddit-mcp-server) — Reddit data as MCP tools for AI agents. - [Trustpilot Reviews Scraper](https://apify.com/makework36/trustpilot-reviews-scraper) — Reviews, ratings and business search on Trustpilot. # Actor input Schema ## `origin` (type: `string`): Origin airport IATA code (e.g. LAX, JFK, LHR, MTY) ## `destination` (type: `string`): Destination airport IATA code (e.g. JFK, EZE, CDG) ## `departDate` (type: `string`): Departure date in YYYY-MM-DD format ## `returnDate` (type: `string`): Return date YYYY-MM-DD for round trip. Leave empty for one-way. ## `adults` (type: `integer`): Number of adult passengers ## `cabinClass` (type: `string`): Cabin class for the flight ## `currency` (type: `string`): Currency code for prices (e.g. USD, EUR, MXN, GBP) ## `maxFlights` (type: `integer`): Maximum number of flight results to return ## Actor input object example ```json { "origin": "LAX", "destination": "JFK", "departDate": "2026-04-25", "adults": 1, "cabinClass": "ECONOMY", "currency": "USD", "maxFlights": 50 } ``` # Actor output Schema ## `dataset` (type: `string`): All scraped items in the default dataset (JSON). ## `csv` (type: `string`): Default dataset formatted as CSV for spreadsheets (Google Sheets, Excel). # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("makework36/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("makework36/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 '{}' | apify call makework36/flight-price-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=makework36/flight-price-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Skyscanner Flight Scraper API", "description": "Compare flight prices from 7 sources: Google Flights, Kiwi, Travelpayouts, Ryanair, EasyJet, Wizz Air, Norwegian. One API call.", "version": "0.3", "x-build-id": "TydQ6X6EtfRUniCGP" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/makework36~flight-price-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-makework36-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/makework36~flight-price-scraper/runs": { "post": { "operationId": "runs-sync-makework36-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/makework36~flight-price-scraper/run-sync": { "post": { "operationId": "run-sync-makework36-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": "Origin airport IATA code (e.g. LAX, JFK, LHR, MTY)", "default": "LAX" }, "destination": { "title": "Destination airport", "type": "string", "description": "Destination airport IATA code (e.g. JFK, EZE, CDG)", "default": "JFK" }, "departDate": { "title": "Departure date", "type": "string", "description": "Departure date in YYYY-MM-DD format", "default": "2026-04-25" }, "returnDate": { "title": "Return date (optional)", "type": "string", "description": "Return date YYYY-MM-DD for round trip. Leave empty for one-way." }, "adults": { "title": "Adults", "minimum": 1, "maximum": 9, "type": "integer", "description": "Number of adult passengers", "default": 1 }, "cabinClass": { "title": "Cabin class", "enum": [ "ECONOMY", "PREMIUM_ECONOMY", "BUSINESS", "FIRST" ], "type": "string", "description": "Cabin class for the flight", "default": "ECONOMY" }, "currency": { "title": "Currency", "type": "string", "description": "Currency code for prices (e.g. USD, EUR, MXN, GBP)", "default": "USD" }, "maxFlights": { "title": "Max flights", "minimum": 1, "maximum": 200, "type": "integer", "description": "Maximum number of flight results to return", "default": 50 } } }, "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 } } } } } } } } } } ```