# Google Flights Scraper: Price Calendar & Flight Price Tracker (`wireless_tiramisu/google-flights-price-calendar`) Actor

\[$0.30/1K dates] Google Flights scraper & flight price tracker API. Find the cheapest day to fly with a price calendar up to 11 months ahead, get full itineraries, search many routes & airports at once, and get price-drop alerts for cheap holiday flights. No browser, no start fee.

- **URL**: https://apify.com/wireless_tiramisu/google-flights-price-calendar.md
- **Developed by:** [Alexis Quiroga](https://apify.com/wireless_tiramisu) (community)
- **Categories:** Travel, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 calendar days

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Flights Scraper: Price Calendar & Flight Price Tracker

**Google Flights scraper and flight price tracker API.** For any route, it gives you the **cheapest day to fly** from a flexible-date **price calendar** (up to ~11 months ahead). It also returns **full flight itineraries** (airlines, flight numbers, times, stops, layovers, CO₂, Google's low/typical/high price verdict and ~60 days of price history) and **price-drop alerts** between runs.

Use it as an unofficial **Google Flights API** to find **cheap flights**, track **Black Friday and Christmas airfares**, build **fare alerts** for a deal site or newsletter, or compare departure airports for clients. No browser, no API key and no start fee: you pay per result.

### What it does

- 📅 **Flight price calendar (flexible dates):** the lowest fare for **every departure date** in your window, one-way or round trip with a fixed trip length. Each request covers about 60 days, so a whole month costs a few cents.
- 🏆 **Cheapest day to fly finder:** every date is ranked by price (`rankByPrice`, `isCheapest`, `% above cheapest`, `savings vs average`). The `CHEAPEST_DAYS` record lists the top 10 dates and the **cheapest weekday** per route.
- ✈️ **Full itineraries:** price, airlines, flight numbers, departure/arrival, duration, stops, layovers, aircraft, legroom, CO₂, and Google's **price level (low / typical / high)** with its typical price range and price history. You can get them for your date and/or automatically for the **N cheapest days**.
- 🗺️ **Multi-route and multi-origin:** `"JFK,EWR,LGA-MIA,FLL"` expands to 6 routes. You can also give origin and destination lists to find the cheapest departure airport. Up to 100 routes per run.
- 🔔 **Flight price tracker and fare alerts:** with monitoring on, every price is compared with the previous run (`UP`, `DOWN`, `SAME`, `NEW`, `NOW_AVAILABLE`, `NOW_UNAVAILABLE`). Price drops above your threshold go to an `ALERTS` record, ready for email, Slack, Zapier, Make or n8n.
- 🎛️ **Filters:** stops (nonstop, ≤1, ≤2), cabin (economy to first), adults, children, infants, max price, currency, country (point of sale) and language.
- 🛡️ **Reliable:** fast HTTP requests (no headless browser), automatic retries with fresh sessions and proxy IPs. A failing route is reported in the run summary and never kills the whole run.

### Use cases

#### Black Friday, Thanksgiving and Christmas fare tracking

Holiday fares move daily. Put your holiday window in the price calendar, schedule the actor every morning and turn on **Detect price changes**. Each run tells you which days got cheaper and by how much, and the `ALERTS` record holds only the drops. Use it to catch the best day to fly home for Christmas or a Black Friday flight deal.

#### Travel agencies and corporate travel

Compare several departure airports and dates for a client or group in one run, for example every New York airport to Florida over the school holidays. Then send the cheapest options with real flight numbers and times. The `googleFlightsUrl` field opens the exact search on Google Flights.

#### Deal sites, newsletters and travel bloggers

Monitor dozens of routes, flag dates whose price is far below the route average (`savingsVsAvg`, `priceLevel: "low"`) and publish "cheapest time to fly to X" content with real data.

#### Airfare research and analytics

Build route price curves, study seasonality and weekday effects, and compare against Google's typical price range and 60-day price history.

#### Apps and AI agents

Clean JSON through the Apify API: plug flight prices into your travel app, spreadsheet, dashboard or AI agent.

### Quick start

1. Click **Try for free**. The example input searches **JFK → LAX**: a 31-day price calendar starting 30 days from today, plus the 10 best flights for that date and for the cheapest day.
2. Press **Start**. A run like this usually finishes in well under a minute.
3. Open the **Price calendar**, **Flights** or **Price changes** views, or download JSON, CSV or Excel.

### Example input

**Cheapest day to fly home for Christmas (one way, whole of December):**

```json
{
  "routes": ["JFK-LAX"],
  "tripType": "oneWay",
  "dateRangeStart": "2026-12-01",
  "dateRangeEnd": "2026-12-31",
  "includeFlights": false,
  "flightsForCheapestDays": 3,
  "maxFlightsPerSearch": 10
}
```

**Holiday round trips from three New York airports to Florida (10-day trips), as a daily fare alert:**

```json
{
  "routes": ["JFK,EWR,LGA-MIA,FLL"],
  "tripType": "roundTrip",
  "tripLengthDays": 10,
  "dateRangeStart": "2026-12-15",
  "dateRangeEnd": "2027-01-10",
  "includeFlights": false,
  "monitorChanges": true,
  "monitorId": "xmas-nyc-florida",
  "alertDropPct": 5
}
```

**Business class, max 1 stop, 2 adults, prices in EUR for the Spanish market:**

```json
{
  "routes": ["MAD-JFK"],
  "tripType": "roundTrip",
  "departureDate": "2026-12-20",
  "returnDate": "2027-01-03",
  "cabin": "business",
  "stops": "max1",
  "adults": 2,
  "currency": "EUR",
  "country": "es"
}
```

### Example output

Real rows from a JFK → LAX run with the example input (one way, economy, 1 adult, USD), captured on 6 Oct 2026. Prices change constantly.

**Price calendar (`type: "calendarDay"`), sorted by price:**

| departureDate | weekday | price | rankByPrice | isCheapest | pctAboveRouteMin | savingsVsAvg |
|---|---|---|---|---|---|---|
| 2026-12-05 | Sat | 169 | 1 | true | 0 | 64 |
| 2026-11-06 | Fri | 177 | 2 | false | 4.7 | 56 |
| 2026-11-13 | Fri | 177 | 3 | false | 4.7 | 56 |
| 2026-12-01 | Tue | 179 | 4 | false | 5.9 | 54 |

**Flights for the cheapest day (`type: "flight"`, `searchReason: "cheapestDay"`):**

| price | airlines | flightNumbers | departure | arrival | durationMin | stops | priceLevel |
|---|---|---|---|---|---|---|---|
| 169 | JetBlue | B6 418, B6 487 | 2026-12-05T12:35 | 2026-12-05T20:40 | 665 | 1 | typical |
| 179 | JetBlue | B6 323 | 2026-12-05T11:00 | 2026-12-05T14:19 | 379 | 0 | typical |
| 179 | Delta | DL 1788 | 2026-12-05T12:00 | 2026-12-05T15:04 | 364 | 0 | typical |
| 179 | Delta | DL 738 | 2026-12-05T15:25 | 2026-12-05T18:30 | 365 | 0 | typical |

Each flight also includes `layovers`, `segments` (aircraft, legroom, operating carrier), `co2Grams`, `priceInsights` (typical range and price history) and `googleFlightsUrl`. With monitoring on, every row also gets `previousPrice`, `priceChange`, `priceChangePct` and `changeType`.

**Key-value store records:**

- `CHEAPEST_DAYS`: per route, the top 10 cheapest dates, min/avg/max price and the cheapest weekday.
- `ALERTS`: price drops since the previous run (monitoring only).
- `RUN_SUMMARY`: counts, cheapest date per route, failures and change totals.

### Pricing: cost per 1,000 results

Pay per event. There's no start fee and no monthly rental. Platform usage is included.

| Event | What you get | Price per result | Per 1,000 results |
|---|---|---|---|
| `calendar-day` | Lowest fare for one departure date on one route | $0.0003 | **$0.30** |
| `flight` | One full itinerary with all details | $0.0015 | **$1.50** |

**Example costs:**

- The example input (31 calendar days + 20 flights) costs ≈ **$0.04**.
- A 6-route holiday calendar of 27 days (162 calendar days) costs ≈ **$0.05** per run. Run daily for a month, it's ≈ $1.50.
- A whole year of dates for one route (~330 calendar days) costs ≈ **$0.10**.

Set **Maximum cost per run** in the run options and the actor stops cleanly when it reaches the limit. You can try it with the monthly free credit of the Apify Free plan.

### How to set up fare alerts

1. Configure your routes and dates. Turn on **Detect price changes** and give the watchlist a **Monitor ID**.
2. Create a **Schedule** in Apify (e.g. daily at 08:00).
3. Add an integration or webhook (email, Slack, Zapier, Make, n8n) that reads the `ALERTS` record, or filter dataset rows where `changeType` is `DOWN`.

### FAQ

**Is this the official Google Flights API?** No. Google doesn't offer a public Google Flights API. This actor collects the publicly visible prices from Google Flights and returns them as structured data you can use through the Apify API.

**Do I need a Google account, API key or browser?** No.

**Are prices per person?** No. They're the total for all passengers you set, as Google Flights shows them. Round-trip prices include the return flight.

**Why can a calendar price differ slightly from the flight list?** The calendar is Google's lowest fare for each date. The flight list is a live search for one date. Use *Full flights for the N cheapest days* to check the best dates live.

**Can I search city codes like NYC or LON?** Use airport codes and list several airports, e.g. `JFK,EWR,LGA-LHR,LGW`.

**How far ahead can I search?** The calendar goes up to about 11 months (330 days) from today.

**Can it track a specific flight?** Yes, as long as it appears in the results (raise *Max flights per search* if needed). With monitoring on, each returned itinerary is matched with the previous run by route, date and flight numbers.

**Is scraping Google Flights legal?** The actor only reads publicly available fare data and collects no personal data. You're responsible for using the data in line with applicable laws and the website's terms.

### Support

Need another field, a new filter or found a bug? Open an issue in the **Issues** tab.

# Actor input Schema

## `routes` (type: `array`):

Routes as ORIGIN-DESTINATION using 3-letter IATA airport codes, e.g. "JFK-LAX". Separate several airports with commas to expand every combination: "JFK,EWR,LGA-MIA,FLL" gives 6 routes.

## `origins` (type: `array`):

Optional. Origin airports (IATA codes). The actor checks every origin × destination combination. Useful for finding the cheapest departure airport.

## `destinations` (type: `array`):

Optional. Destination airports (IATA codes), combined with each origin above.

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

One-way or round trip. For round trips, calendar prices are for a fixed trip length (see below).

## `departureDate` (type: `string`):

Departure date (YYYY-MM-DD) for the full flight list. Also the default start of the price calendar. Defaults to 30 days from today.

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

Return date (YYYY-MM-DD) for round trips. If empty, Trip length is used instead.

## `tripLengthDays` (type: `integer`):

Number of nights between departure and return for round-trip calendars, e.g. 7 for a week-long holiday trip.

## `includeCalendar` (type: `boolean`):

Get the lowest price for every departure date in the date range (Google's date grid). About 60 days per request, so it's fast and cheap.

## `dateRangeStart` (type: `string`):

First departure date in the calendar (YYYY-MM-DD). Defaults to the departure date.

## `dateRangeEnd` (type: `string`):

Last departure date in the calendar (YYYY-MM-DD). Defaults to 30 days after the start. Up to about 11 months ahead.

## `flightsForCheapestDays` (type: `integer`):

Cheapest-day finder: after building the calendar, also fetch the full flight list (airlines, times, stops) for the N cheapest departure dates of each route. Set 0 to turn it off.

## `includeFlights` (type: `boolean`):

Fetch every itinerary (price, airlines, times, stops, layovers, flight numbers, aircraft, CO₂, price insights) for the departure date.

## `maxFlightsPerSearch` (type: `integer`):

Maximum number of itineraries saved per route and date (best flights first, then the rest by Google's ranking).

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

Optional. Skip itineraries above this price (in the chosen currency).

## `stops` (type: `string`):

Limit the number of stops. Applies to both the calendar and the flights.

## `cabin` (type: `string`):

Seat class.

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

Number of adults.

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

Number of children.

## `infantsInSeat` (type: `integer`):

Infants with their own seat.

## `infantsOnLap` (type: `integer`):

Infants on an adult's lap (one per adult).

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

3-letter currency code for all prices, e.g. USD, EUR, GBP, CAD, AUD, MXN.

## `country` (type: `string`):

2-letter country code for the Google market (gl), e.g. us, gb, es, de. Prices can differ by market.

## `language` (type: `string`):

Language code (hl) for airline and airport names, e.g. en, es, de, fr.

## `monitorChanges` (type: `boolean`):

Compare every price with the previous run (UP / DOWN / SAME / NEW / NOW_AVAILABLE / NOW_UNAVAILABLE) and save the price drops to the ALERTS record. Schedule the actor to get fare alerts.

## `monitorId` (type: `string`):

Optional name for this watchlist. Runs with the same Monitor ID are compared with each other. If empty, an ID is derived from the routes and settings.

## `alertDropPct` (type: `integer`):

Only add price drops of at least this percentage to the ALERTS record. 0 = every drop.

## `maxRetries` (type: `integer`):

Each failed request is retried with a fresh session and IP, with exponential backoff.

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

Apify Proxy is recommended. Datacenter proxy works for most runs.

## Actor input object example

```json
{
  "routes": [
    "JFK-LAX"
  ],
  "tripType": "oneWay",
  "tripLengthDays": 7,
  "includeCalendar": true,
  "flightsForCheapestDays": 1,
  "includeFlights": true,
  "maxFlightsPerSearch": 10,
  "stops": "any",
  "cabin": "economy",
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "currency": "USD",
  "country": "us",
  "language": "en",
  "monitorChanges": false,
  "alertDropPct": 0,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `calendar` (type: `string`):

Lowest price for each departure date and route (calendarDay items).

## `flights` (type: `string`):

Full itineraries with airlines, times, stops, layovers and price insights (flight items).

## `priceChanges` (type: `string`):

Every item with its previous price and change type (when monitoring is on).

## `cheapestDays` (type: `string`):

Top 10 cheapest departure dates, min/avg/max price and cheapest weekday per route.

## `alerts` (type: `string`):

Prices that dropped since the previous run (monitoring only). Ready for email/Slack/webhook alerts.

## `runSummary` (type: `string`):

Counts, cheapest date per route, failures and change totals.

# 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 = {
    "routes": [
        "JFK-LAX"
    ],
    "flightsForCheapestDays": 1,
    "maxFlightsPerSearch": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("wireless_tiramisu/google-flights-price-calendar").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 = {
    "routes": ["JFK-LAX"],
    "flightsForCheapestDays": 1,
    "maxFlightsPerSearch": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("wireless_tiramisu/google-flights-price-calendar").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 '{
  "routes": [
    "JFK-LAX"
  ],
  "flightsForCheapestDays": 1,
  "maxFlightsPerSearch": 10
}' |
apify call wireless_tiramisu/google-flights-price-calendar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wireless_tiramisu/google-flights-price-calendar"
        }
    }
}
```

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/7yvtpVLAzfxqZoPdr/builds/0vGvgQ7P3m1VBApmS/openapi.json