# Transavia Scraper — Flight Prices & Availability (`studio-amba/transavia-scraper`) Actor

Scrape live Transavia flight prices: a day-by-day fare calendar for any route, enriched with per-flight detail (flight number, times, fare class, seats left). No login required.

- **URL**: https://apify.com/studio-amba/transavia-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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

### What does Transavia Scraper do?

**Transavia Scraper** extracts live flight prices and availability from
[transavia.com](https://www.transavia.com), the KLM/Air France-group budget
airline flying from Amsterdam, Rotterdam, and several French bases across
Europe and North Africa. Give it an origin and destination airport and it
returns a day-by-day fare calendar for that route, enriched with real
flight-number-level detail — departure and arrival times, fare class, and
seats left — wherever Transavia's own booking API exposes it. No login
required.

Use it to collect structured flight data via the Apify platform with full
**API access, scheduling, integrations**, and no need to run a browser
yourself.

### Why use Transavia Scraper?

- **Price monitoring** — Track fares on specific routes over time and catch
  price drops before they disappear
- **Fare calendar at a glance** — See which days in a date window are
  Transavia's "low fare" days versus "regular fare" days, without clicking
  through the site day by day
- **Fare analytics** — Build datasets for route pricing trends, seasonality,
  and seat availability across Transavia's network
- **Meta-search / travel apps** — Feed live Transavia pricing into your own
  booking tool or comparison site
- **Budget travel planning** — Compare prices and seat availability across
  fare classes and dates before booking

### How to use Transavia Scraper

1. Go to the **Input** tab
2. Enter an **Origin airport** IATA code (e.g. `AMS`, `RTM`, `ORY`)
3. Enter a **Destination airport** IATA code (e.g. `BCN`, `FAO`)
4. Optionally set a **Date from** / **Date to** window (`YYYY-MM-DD`) and the
   number of adult passengers to price
5. Click **Start** and wait for the run to finish
6. Download your data from the **Output** tab in JSON, CSV, Excel, or other
   formats

Running the actor with `{}` input scrapes a 30-day fare calendar for
Amsterdam to Barcelona (`AMS`-`BCN`), a real, daily Transavia route, starting
14 days out.

### How the fare calendar and flight detail fit together

Every date in the requested window gets a fare-calendar row (the lowest
price Transavia shows for that day, classified as a `lowFare` or
`regularFare` day). For as many of those dates as fit within `maxResults`
(up to 30 dates per run to keep runs fast), the actor also fetches
Transavia's own flight-availability data for that date — this turns one
calendar row into one row per actual scheduled flight, with a real flight
number, departure/arrival time, fare class, and seats left. Dates beyond
that cap still get a fare-calendar row (price and fare type, without
flight-level fields).

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `origin` | String | No | Departure airport IATA code (default: `AMS`) |
| `destination` | String | No | Arrival airport IATA code (default: `BCN`) |
| `dateFrom` | String | No | Start of the search window, `YYYY-MM-DD` (default: 14 days from today) |
| `dateTo` | String | No | End of the search window, `YYYY-MM-DD` (default: 30 days after `dateFrom`) |
| `adults` | Integer | No | Number of adult passengers to price the fare for (default: 1) |
| `maxResults` | Integer | No | Maximum result rows to return (default: 60) |

### Output

| Field | Type | Example |
|-------|------|---------|
| `route` | String | `"AMS-BCN"` |
| `origin` | String | `"AMS"` |
| `destination` | String | `"BCN"` |
| `date` | String | `"2026-10-15"` |
| `flightNumber` | String or null | `"HV5131"` (null on calendar-only rows) |
| `airline` | String | `"Transavia"` |
| `direct` | Boolean | `true` |
| `departureTime` | String or null | `"2026-10-15T06:00:00+02:00"` |
| `arrivalTime` | String or null | `"2026-10-15T08:10:00+02:00"` |
| `durationMinutes` | Number or null | `130` |
| `price` | Number or null | `88` |
| `currency` | String | `"EUR"` |
| `fareType` | String or null | `"lowFare"` or `"regularFare"` |
| `fareClass` | String or null | `"N"` (only on flight-level rows) |
| `availableSeats` | Number or null | `4` (only on flight-level rows) |
| `url` | String | Best-effort deep link to this route on transavia.com |

### Example output

```json
{
    "route": "AMS-BCN",
    "origin": "AMS",
    "destination": "BCN",
    "date": "2026-10-15",
    "flightNumber": "HV5131",
    "airline": "Transavia",
    "direct": true,
    "departureTime": "2026-10-15T06:00:00+02:00",
    "arrivalTime": "2026-10-15T08:10:00+02:00",
    "durationMinutes": 130,
    "price": 88,
    "currency": "EUR",
    "fareType": "lowFare",
    "fareClass": "N",
    "availableSeats": 4,
    "url": "https://www.transavia.com/book/en-eu/search-a-flight?ds=AMS&as=BCN&om=10&oy=2026&r=False",
    "scrapedAt": "2026-08-30T14:38:44.708Z"
}
```

### How much does it cost to scrape Transavia?

transavia.com is Cloudflare-protected, so this actor uses a real,
JS-executing browser session (Bright Data Scraping Browser) rather than a
plain HTTP request. It charges $0.01 per run start (based on its memory
allocation) plus $0.005 per result. A typical 20-30 day fare calendar costs
a few tens of cents. A run's usage cost only settles after it reports
SUCCEEDED.

### Limitations

- **Currency is always EUR.** Transavia's fare API doesn't return a currency
  field; every Transavia base is in the Eurozone, so EUR is hardcoded
  rather than guessed.
- **Only genuine Transavia (HV) flights.** This actor searches Transavia's
  own direct network only — it does not return KLM or partner-airline
  interline connections that Transavia's own site occasionally offers on
  routes it doesn't fly directly.
- **Flight-level detail is capped at 30 dates per run** to keep run times
  short; dates beyond that still get a fare-calendar price row, just
  without a flight number or times. Raise this by running the actor again
  with a narrower date window.
- Data is scraped from the public website and may change without notice.
- Respect Transavia's terms of service and use responsibly.

### FAQ and support

**Is it legal to scrape Transavia?**
Transavia Scraper accesses only publicly available flight pricing data that
any visitor can see, without logging in or bypassing payment. Always review
and comply with the target website's Terms of Service before use.

**Why did my run come back empty?**
Either the origin/destination pair isn't a real Transavia route, or
Cloudflare blocked every browser session attempted during the run. The
actor retries automatically across fresh sessions before giving up.

**I found a bug or need help**
Please submit an issue on the [Issues tab](https://console.apify.com/actors/transavia-scraper/issues) and we'll get back to you quickly. For custom scraping solutions, reach out via the same channel.

### How to scrape Transavia data

1. Go to this actor's page on the [Apify Store](https://apify.com/store).
2. Click **Try for free** to open it in Apify Console.
3. Enter your origin and destination airport codes.
4. Set a date window, passenger count, and the maximum number of results if
   needed.
5. Click **Start** and wait for the run to finish — most searches complete
   in under a minute.
6. Download your data in JSON, CSV, Excel, or connect it to your workflow
   via the Apify API.

You can also schedule daily runs to track fares on a route over time, set up
webhooks for price-drop notifications, or integrate results directly into
your own booking or comparison tool using the [Apify API](https://docs.apify.com/api).

### Related scrapers

- [Vueling Scraper](https://apify.com/store) — Spain's largest low-cost
  carrier, same budget-airline cluster
- [Wizz Air Scraper](https://apify.com/store) — Central/Eastern Europe's
  largest budget network
- [Volotea Scraper](https://apify.com/store) — Spain/Italy/France
  point-to-point routes to smaller cities

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
price-drop alerts, delta detection, and delivery to your inbox, Google
Sheets, or API — maintenance included. We can also build a custom version
with round-trip search, multi-city routing, or your exact fields.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

Departure airport IATA code (e.g. 'AMS' for Amsterdam, 'RTM' for Rotterdam, 'ORY' for Paris Orly).

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

Arrival airport IATA code (e.g. 'BCN' for Barcelona, 'FAO' for Faro).

## `dateFrom` (type: `string`):

Start of the date window to search, in YYYY-MM-DD format. Defaults to 14 days from today.

## `dateTo` (type: `string`):

End of the date window to search, in YYYY-MM-DD format. Defaults to 30 days after 'Date from'.

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

Number of adult passengers to price the fare for.

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

Maximum number of fare/flight results to return.

## `sbrWsCdp` (type: `string`):

Optional: your own Bright Data Scraping Browser CDP endpoint. Leave empty to use the built-in unlocking service.

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

Legacy field, kept for backwards compatibility. Fetching goes through the built-in Bright Data Scraping Browser, so this is ignored.

## Actor input object example

```json
{
  "origin": "AMS",
  "destination": "BCN",
  "adults": 1,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "origin": "AMS",
    "destination": "BCN",
    "adults": 1,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/transavia-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": "AMS",
    "destination": "BCN",
    "adults": 1,
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/transavia-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "origin": "AMS",
  "destination": "BCN",
  "adults": 1,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/transavia-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

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