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

Scrape live flight prices and availability from Vueling's public fare API: flight numbers, departure/arrival times, and a full future price calendar for any origin and destination airport pair.

- **URL**: https://apify.com/studio-amba/vueling-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 Vueling Scraper do?

**Vueling Scraper** extracts live flight prices and availability directly
from [Vueling's](https://www.vueling.com) public fare API — the same data
that powers the fare calendar on vueling.com. Give it an origin and
destination airport and it returns a full day-by-day price calendar for
that route, typically covering the next 7-10 months. No login or booking
session 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 — Vueling's fare API is a plain JSON endpoint, so this actor makes
one lightweight request per run instead of rendering a page.

### Why use Vueling Scraper?

- **Price monitoring** — Track fares on specific Vueling routes over time
  and catch price drops before they disappear
- **Cheapest-day finder** — See months of price data for a route in one run
  to spot the cheapest day to fly
- **Fare analytics** — Build datasets for route pricing trends, seasonality,
  and demand signals across Vueling's Spain-centred network
- **Meta-search / travel apps** — Feed live Vueling pricing into your own
  booking tool or comparison site
- **Corporate travel** — Check fares for upcoming business trips in bulk

### How to use Vueling Scraper

1. Go to the **Input** tab
2. Enter an **Origin airport** IATA code (e.g. `BCN`, `MAD`, `BRU`)
3. Enter a **Destination airport** IATA code (e.g. `MAD`) — Vueling's fare
   API requires a specific route, there is no "explore everywhere" mode
4. Optionally set **Currency** and **Max results**
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

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `origin` | String | Yes | Departure airport IATA code (default: `BCN`) |
| `destination` | String | Yes | Arrival airport IATA code (default: `MAD`) |
| `currency` | String | No | Price currency code, e.g. `EUR`, `GBP` (default: `EUR`) |
| `maxResults` | Integer | No | Maximum daily fares to return (default: 300) |
| `proxyConfiguration` | Object | No | Residential proxy by default — Vueling's API stalls requests from datacenter IPs |

### Output

| Field | Type | Example |
|-------|------|---------|
| `route` | String | `"BCN-MAD"` |
| `origin` / `destination` | String | `"BCN"` / `"MAD"` |
| `flightNumber` | String | `"VY5008"` |
| `departureTime` | String | `"2026-08-30T05:00:00"` |
| `arrivalDate` | String | `"2026-08-30"` |
| `price` | Number | `243` |
| `currency` | String | `"EUR"` |
| `tax` | Number | `0` |
| `classOfService` | String | `"EI"` |
| `isLowPrice` | Boolean | `false` |
| `isConnectionFlight` | Boolean | `false` |
| `available` | Boolean | `true` |
| `url` | String | Deep link to book on vueling.com |

### Example output

```json
{
    "route": "BCN-MAD",
    "origin": "BCN",
    "destination": "MAD",
    "flightNumber": "VY5008",
    "departureTime": "2026-08-30T05:00:00",
    "arrivalDate": "2026-08-30",
    "price": 243,
    "currency": "EUR",
    "tax": 0,
    "classOfService": "EI",
    "isLowPrice": false,
    "isConnectionFlight": false,
    "available": true,
    "url": "https://www.vueling.com/en/flights/bcn-mad",
    "scrapedAt": "2026-08-29T19:36:10.036Z"
}
```

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

Vueling's fare API is a plain JSON endpoint, so this actor makes one
lightweight direct HTTP request per run — no browser rendering needed. It
does use a residential proxy by default (Vueling stalls requests from
Apify's datacenter IPs), which costs more per request than a proxy-free
actor but is still cheap relative to browser-based scrapers, since it's
still a single request per run — one run returns an entire route's price
calendar (up to `maxResults` days), so the cost per result is a small
fraction of a cent. The Apify Free plan includes $5 of monthly credits. A
run's usage cost only settles after it reports SUCCEEDED.

### Limitations

- **One route per run.** Vueling's fare API requires both an origin and a
  destination — there's no "cheapest fare to anywhere" mode like some other
  airline fare-finders offer. Run it once per route you want to track.
- **No exact arrival time.** Vueling's API reports the arrival calendar
  date but always returns midnight as the time component, so `arrivalDate`
  is date-only — it does not include flight duration or a real arrival
  time.
- **No fare-bundle breakdown.** The public fare API exposes a single price
  per day; bundle upgrades (checked bag, seat selection, etc.) require an
  authenticated booking session that isn't publicly accessible.
- Data is scraped from the public website and may change without notice.
- Respect Vueling's terms of service and use responsibly.

### FAQ and support

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

**Why do I need both an origin and a destination?**
Vueling's fare API rejects requests with no destination (returns a 400
error), unlike some competitors that offer an "explore everywhere" mode. Set
both airport codes to get results.

**What if I enter a route Vueling doesn't fly?**
The actor fails the run with a clear error rather than returning an empty
success — Vueling's API returns a 404 for routes it doesn't operate, so
check both IATA codes are correct and served by Vueling.

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

### How to scrape Vueling flight 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 IATA codes.
4. Set currency if you need something other than EUR.
5. Click **Start** and wait for the run to finish — most runs 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, or
integrate results directly into your own booking or comparison tool using
the [Apify API](https://docs.apify.com/api).

### 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 multi-route sweeps 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. 'BRU' for Brussels, 'BCN' for Barcelona, 'MAD' for Madrid).

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

Arrival airport IATA code (e.g. 'MAD' for Madrid). Vueling's fare API requires a specific destination — there is no 'search everywhere' mode.

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

Currency code for prices (e.g. EUR, GBP).

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

Maximum number of daily fares to return. Vueling's API returns a full future price calendar (typically 200-300 days) per route in one call.

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

Vueling's fare API silently stalls requests from datacenter IPs, so a residential proxy is used by default — leave this as-is unless you have your own proxy.

## Actor input object example

```json
{
  "origin": "BCN",
  "destination": "MAD",
  "currency": "EUR",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "BCN",
    "destination": "MAD",
    "currency": "EUR",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/vueling-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": "BCN",
    "destination": "MAD",
    "currency": "EUR",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/vueling-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": "BCN",
  "destination": "MAD",
  "currency": "EUR",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/vueling-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/vueling-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/rFbH6bp192k7cRVkS/builds/udcO6QPvnPpCazlFI/openapi.json