# Wizz Air Flight Scraper - Fare Calendar and Cheapest Days (`benthepythondev/wizzair-flight-scraper`) Actor

Scrape Wizz Air day-by-day public fares by airport route and date window. Export prices, currencies, service classes, airport metadata and booking links.

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

## Pricing

from $1.20 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Wizz Air Flight Scraper - Fare Calendar and Cheapest Days

Collect **live Wizz Air fare-calendar data** by airport route and flexible date window. The Actor returns one structured row for each day with a currently published price, including route, travel date, amount, currency, fare class, airport metadata, passenger context, and a direct Wizz Air booking link.

Search one route or batch several departure and arrival airport codes. Use one-way mode for outbound fare research or round-trip mode to scan the reverse route over a separate return window. Results can be sorted by price or date, filtered by a maximum fare, exported as JSON, CSV, Excel, XML, or RSS, accessed through the Apify API, and connected to Make, Zapier, n8n, webhooks, spreadsheets, databases, and travel-alert services.

### What can you use it for?

- Find the cheapest days to fly a Wizz Air route.
- Build daily or weekly fare alerts for selected airport pairs.
- Track route prices over time for travel research and analytics.
- Compare outbound and return calendars before choosing dates.
- Create destination-deal feeds for newsletters or travel communities.
- Populate a flight-price dashboard, spreadsheet, database, or internal tool.
- Monitor how prices change as the departure date approaches.
- Research Wizz Air route currencies and airport connectivity.
- Generate content such as "cheapest days to fly from London to Budapest."

Unlike a single-date booking check, the fare-calendar approach covers a bounded date window and keeps one row per priced day. This makes it useful for flexible travelers and automated price monitoring.

### Input

#### One-way fare calendar

```json
{
  "departureAirports": ["LTN"],
  "arrivalAirports": ["BUD"],
  "tripType": "oneWay",
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "maxResultsPerRoute": 20,
  "sortBy": "cheapest"
}
```

#### Exact dates and several routes

```json
{
  "departureAirports": ["SOF", "LTN"],
  "arrivalAirports": ["BUD", "FCO"],
  "departDateFrom": "2026-08-01",
  "departDateTo": "2026-08-31",
  "adults": 1,
  "children": 0,
  "infants": 0,
  "maxPrice": 100,
  "maxResultsPerRoute": 25
}
```

Every departure airport is paired with every arrival airport. Identical codes are skipped, and a run is limited to 30 route pairs to keep requests and cost bounded.

#### Round-trip calendar

```json
{
  "departureAirports": ["LTN"],
  "arrivalAirports": ["BUD"],
  "tripType": "roundTrip",
  "departDateFrom": "2026-08-01",
  "departDateTo": "2026-08-14",
  "returnDateFrom": "2026-08-15",
  "returnDateTo": "2026-08-28",
  "maxResultsPerRoute": 20
}
```

Round-trip mode produces outbound rows for `LTN` to `BUD` and return rows for `BUD` to `LTN`. Each row is still an individual fare day, so you can combine the dates according to your own trip-length and budget rules.

### Date controls

Use `departDateFrom` and `departDateTo` for exact ISO dates in `YYYY-MM-DD` format. When they are empty, `daysAheadStart` and `daysAheadEnd` create a moving window relative to each run. Relative dates are useful for scheduled Tasks because the calendar advances automatically.

Past dates are never requested. The outbound window is limited to 365 days. In round-trip mode, the default return window begins one day after the outbound window and lasts 14 days unless exact return dates are supplied.

`dayInterval` controls request batching. The default of nine allows the Actor to cover a wide window with fewer source requests. Lower values create smaller overlapping fare-chart requests. The Actor always filters the source response back to the exact requested range.

### Passenger and fare settings

Set `adults`, `children`, and `infants` to preserve the passenger context in the lookup and booking link. At least one adult is required, and the number of infants cannot exceed the number of adults.

Enable `wizzDiscountClub` to request the WIZZ Discount Club fare context exposed by the public fare chart. Membership eligibility and the final checkout price remain subject to Wizz Air's own rules and the traveler's account.

Use `maxPrice` to retain only fare days at or below a chosen amount. The filter is applied in the route's source currency, so do not compare a GBP route and an EUR route as though they use the same unit.

### Output fields

Each default-dataset row represents one unique route, direction, and priced travel day.

| Field | Description |
| --- | --- |
| `id` | Stable direction, route, and date key |
| `rank` | Final output rank after sorting |
| `direction` | `outbound` or `return` |
| `travel_date` | Flight date in `YYYY-MM-DD` format |
| `price` | Published fare-chart amount |
| `currency` | Source currency such as GBP, EUR, or HUF |
| `exchanged_price` | Source-provided converted amount when available |
| `exchanged_currency` | Currency of the converted amount |
| `price_type` | Wizz Air fare-chart availability type |
| `class_of_service` | Public fare class code |
| `has_mac_flight` | Whether the source marks a multi-airport-city flight |
| `wizz_discount_club` | Fare-context setting used for the request |
| `departure_airport_code` | Origin IATA code |
| `departure_airport_name` | Public Wizz Air airport or city name |
| `departure_country`, `departure_country_code` | Origin country metadata |
| `departure_latitude`, `departure_longitude` | Public route-map coordinates |
| `arrival_airport_code` | Destination IATA code |
| `arrival_airport_name` | Destination airport or city name |
| `arrival_country`, `arrival_country_code` | Destination country metadata |
| `booking_url` | Direct pre-filled Wizz Air flight-selection link |
| `search_date_from`, `search_date_to` | Requested date-window provenance |
| `scraped_at` | UTC collection timestamp |

#### Example result

```json
{
  "id": "outbound:LTN:BUD:2026-08-12",
  "rank": 1,
  "direction": "outbound",
  "travel_date": "2026-08-12",
  "price": 45.99,
  "currency": "GBP",
  "price_type": "price",
  "class_of_service": "O",
  "departure_airport_code": "LTN",
  "departure_airport_name": "London Luton",
  "arrival_airport_code": "BUD",
  "arrival_airport_name": "Budapest",
  "wizz_discount_club": false,
  "booking_url": "https://www.wizzair.com/en-gb/booking/select-flight/LTN/BUD/2026-08-12/null/1/0/0/null"
}
```

This example reflects the shape of a live public fare used during validation. Fares, availability, classes, and dates change continuously.

### Pricing

The Actor uses transparent pay-per-event pricing:

- a small Actor-start event covers run initialization;
- every unique priced fare day written to the default dataset is one `result` event at **$0.0015**;
- unavailable, no-data, check-price, out-of-range, over-budget, and duplicate days are not written or charged as results.

At this rate, 1,000 priced fare-day rows cost $1.50 plus the small start event. The Apify Console displays the current price configuration before a run starts.

### Scheduling and fare alerts

Create a saved Task for each route or route group, then schedule it daily or weekly. Relative date fields keep the monitored window moving forward without editing the Task.

A practical alert workflow is:

1. Run a Task for a route and date window.
2. Retrieve the default dataset through the API.
3. Upsert rows by `id`.
4. Compare `price` with the prior observation for the same travel date.
5. Send an alert when the fare falls below your threshold.

For flexible-date research, sort by `cheapest`. For calendar displays and time-series storage, sort by `earliestDate`.

### Extraction and reliability

The Actor discovers Wizz Air's current public backend version from the live website at runtime. It reads airport and route metadata from the public route-map asset and day-by-day prices from the public fare-chart endpoint. This avoids browser coordinates and keeps the 512 MB runtime lightweight.

Requests use Chrome-compatible TLS behavior, bounded retries, request windows, route limits, result limits, and short pacing. Direct access is attempted first. A sticky GB residential session is available only as a fallback if the public backend rate-limits an Apify datacenter request. The run fails explicitly when no priced fare days are available, rather than appearing healthy with an empty dataset.

### Responsible use

The Actor reads public fare and route information at runtime. It does not log in, create bookings, reserve seats, process payments, or access passenger records. It is not affiliated with or endorsed by Wizz Air.

Treat every result as an informational snapshot. The final price, currency conversion, membership eligibility, taxes, fees, seat availability, schedule, and conditions are determined by Wizz Air during checkout. Use proportionate schedules and comply with applicable laws and source terms. Do not overload the service, misrepresent fare availability, or use the output to deceive travelers.

### FAQ

#### Does it require a Wizz Air account or API key?

No. It reads public route and fare-chart information.

#### Does it book flights?

No. It only returns fare data and a booking link. The traveler completes any booking directly with Wizz Air.

#### Why are some calendar days missing?

The Actor writes only days with a positive published fare. Wizz Air may mark other days as unavailable, no data, or requiring a separate price check.

#### Can I search several airports?

Yes. Every departure code is paired with every arrival code, up to 30 route pairs per run.

#### Are prices guaranteed?

No. Fares can change at any time, and checkout may include additional services or eligibility conditions.

#### Can I monitor return fares?

Yes. Use `roundTrip` and provide a return window. Return rows use the reverse route and are labeled `return`.

#### How do I report a problem?

Open an issue on the Actor page with the run ID, route, date window, and expected result. Do not include booking credentials or passenger information. If the Actor saves you time, please leave a Store review; reviews help other users assess it and help prioritize maintenance.

### Related Actors

- [Ryanair Flights Scraper](https://apify.com/benthepythondev/ryanair-flights-scraper) for Ryanair route and fare monitoring.
- [Google Flights Scraper](https://apify.com/benthepythondev/google-flights-scraper) for broader airline comparison workflows.
- [Open Meteo Weather Scraper](https://apify.com/benthepythondev/open-meteo-weather-scraper) for destination forecast enrichment.
- [Public Holidays Scraper](https://apify.com/benthepythondev/public-holidays-scraper) for holiday-aware travel planning.
- [Geocoder OpenStreetMap](https://apify.com/benthepythondev/geocoder-openstreetmap) for destination coordinates and location enrichment.

Keywords: Wizz Air scraper, Wizz Air API, flight fare scraper, cheap flights data, fare calendar, cheapest days to fly, Wizz Air price tracker, flight alerts, Luton Budapest fares, route price monitoring, travel data API, airline fare export.

# Actor input Schema

## `departureAirports` (type: `array`):

Three-letter Wizz Air departure airport codes.

## `arrivalAirports` (type: `array`):

Three-letter Wizz Air arrival airport codes. Every departure/arrival combination is searched.

## `tripType` (type: `string`):

One-way scans the outbound route. Round-trip also scans the reverse route during the return window.

## `departDateFrom` (type: `string`):

Optional YYYY-MM-DD date. Leave empty to use the relative-day fields.

## `departDateTo` (type: `string`):

Optional YYYY-MM-DD date. Leave empty to use the relative-day fields.

## `daysAheadStart` (type: `integer`):

Used when no exact outbound start date is supplied.

## `daysAheadEnd` (type: `integer`):

Used when no exact outbound end date is supplied.

## `returnDateFrom` (type: `string`):

Optional YYYY-MM-DD return-window start for round-trip mode.

## `returnDateTo` (type: `string`):

Optional YYYY-MM-DD return-window end for round-trip mode.

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

Adult passengers used for the fare lookup and booking link.

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

Child passengers used for the fare lookup and booking link.

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

Cannot exceed the number of adults.

## `wizzDiscountClub` (type: `boolean`):

Ask the public fare chart for the WIZZ Discount Club price context.

## `maxPrice` (type: `number`):

Optional maximum price in the route currency.

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

Sort retained fare days by price, date, or source order.

## `dayInterval` (type: `integer`):

Advanced batching control. Nine gives the fewest requests for wide date windows.

## `maxResultsPerRoute` (type: `integer`):

Maximum priced day rows saved for each outbound or return route window.

## Actor input object example

```json
{
  "departureAirports": [
    "LTN",
    "SOF"
  ],
  "arrivalAirports": [
    "BUD"
  ],
  "tripType": "oneWay",
  "departDateFrom": "",
  "departDateTo": "",
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "returnDateFrom": "",
  "returnDateTo": "",
  "adults": 1,
  "children": 0,
  "infants": 0,
  "wizzDiscountClub": false,
  "sortBy": "cheapest",
  "dayInterval": 9,
  "maxResultsPerRoute": 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 = {
    "departureAirports": [
        "LTN",
        "SOF"
    ],
    "arrivalAirports": [
        "BUD"
    ],
    "tripType": "oneWay",
    "daysAheadStart": 1,
    "daysAheadEnd": 30,
    "adults": 1,
    "children": 0,
    "infants": 0,
    "wizzDiscountClub": false,
    "sortBy": "cheapest",
    "dayInterval": 9,
    "maxResultsPerRoute": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/wizzair-flight-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 = {
    "departureAirports": [
        "LTN",
        "SOF",
    ],
    "arrivalAirports": ["BUD"],
    "tripType": "oneWay",
    "daysAheadStart": 1,
    "daysAheadEnd": 30,
    "adults": 1,
    "children": 0,
    "infants": 0,
    "wizzDiscountClub": False,
    "sortBy": "cheapest",
    "dayInterval": 9,
    "maxResultsPerRoute": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/wizzair-flight-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 '{
  "departureAirports": [
    "LTN",
    "SOF"
  ],
  "arrivalAirports": [
    "BUD"
  ],
  "tripType": "oneWay",
  "daysAheadStart": 1,
  "daysAheadEnd": 30,
  "adults": 1,
  "children": 0,
  "infants": 0,
  "wizzDiscountClub": false,
  "sortBy": "cheapest",
  "dayInterval": 9,
  "maxResultsPerRoute": 10
}' |
apify call benthepythondev/wizzair-flight-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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