# Google Flights Scraper & Price Monitor - Airfare API (`groupoject/google-flights-price-monitor`) Actor

Scrape live Google Flights prices, airlines, schedules, stops, connection airports, aircraft and CO2. Search multiple routes or dates, rank cheap fares, and create price alerts. No API key or login.

- **URL**: https://apify.com/groupoject/google-flights-price-monitor.md
- **Developed by:** [Group Oject](https://apify.com/groupoject) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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/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

## Google Flights Scraper & Price Monitor - Airfare API

Search Google Flights and export live airfare results as structured JSON, CSV, Excel, or an API response. This Actor collects flight prices, airlines, schedules, stops, connection airports, aircraft, and emissions without a Google API key or login.

Use one run to search a single trip, compare many routes, or scan up to 31 departure dates. Results are ranked by price and enriched with stable itinerary IDs, per-traveler prices, target-price flags, and route-level fare summaries.

### Why use this flight scraper?

- **Live airfare search** from Google Flights at run time
- **One-way and round-trip flights** in economy, premium economy, business, or first class
- **Bulk route search** for travel sites, agencies, corporate travel teams, and data pipelines
- **Flexible-date scans** to find cheaper departure days
- **Price alerts** with `belowTargetPrice`
- **Direct-flight, stop, airline, and maximum-price filters**
- **Detailed segments** with airport names, local times, duration, and aircraft when available
- **Route summaries** with lowest, median, average, and cheapest direct-flight prices
- **Agent-ready output** for MCP, AI travel assistants, n8n, Make, Zapier, and custom applications
- **No Google Flights API key** and no Google account required

### What data can you extract?

Each flight itinerary includes:

| Field | Description |
| --- | --- |
| `itineraryId` | Stable hash for identifying the same itinerary across runs |
| `rank` | Price rank within the route search |
| `price` / `currency` | Total displayed fare and ISO currency |
| `pricePerTraveler` | Total fare divided by the passenger count |
| `priceTier` | `lowest`, `good`, `typical`, or `high` relative to returned fares |
| `belowTargetPrice` | Whether the fare meets your configured target |
| `airlines` | Marketing or operating airlines shown for the itinerary |
| `airlineCode` | Primary airline IATA code when available |
| `departureAt` / `arrivalAt` | Local flight timestamps |
| `durationMinutes` | Source segment durations plus same-airport connections; excludes a round-trip stay and is null when a transfer cannot be calculated |
| `stops` / `isDirect` | Connection count and direct-flight flag |
| `segments` | Detailed airport, schedule, duration, and aircraft data |
| `layoverAirports` | Connection airport codes derived from the itinerary |
| `carbonGrams` | Google Flights CO2 estimate when available |
| `carbonVsTypicalPercent` | Difference from typical emissions for the route |
| `googleFlightsUrl` | Reproducible Google Flights search URL |
| `scrapedAt` | UTC extraction timestamp |

When `includeRouteSummary` is enabled, the Actor also writes one `route_summary` record per search. It contains the result count, lowest fare, median fare, average fare, direct-flight count, and cheapest direct fare.

### Quick start

Search a one-way economy flight:

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-10-15",
  "maxResultsPerSearch": 50
}
```

Search a round trip:

```json
{
  "origin": "JFK",
  "destination": "LHR",
  "departureDate": "2026-11-10",
  "returnDate": "2026-11-17",
  "cabinClass": "economy",
  "adults": 2,
  "currency": "USD"
}
```

### Find the cheapest departure date

Set `departureDateEnd` to search every day in an inclusive date range:

```json
{
  "origin": "CMN",
  "destination": "CDG",
  "departureDate": "2026-10-01",
  "departureDateEnd": "2026-10-07",
  "directOnly": true,
  "targetPrice": 180,
  "maxResultsPerSearch": 30
}
```

The range is limited to 31 days to keep runs predictable. Every date becomes a separate search and receives its own route summary.

### Search multiple flight routes

Use `additionalRoutes` to compare destinations or maintain a flight-price watchlist:

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-10-15",
  "additionalRoutes": [
    {
      "origin": "JFK",
      "destination": "SFO",
      "departureDate": "2026-10-15"
    },
    {
      "origin": "BOS",
      "destination": "LHR",
      "departureDate": "2026-11-10",
      "returnDate": "2026-11-17"
    }
  ],
  "maxConcurrency": 2
}
```

You can submit up to 50 additional routes and up to 100 route/date searches per run.

### Filter cheap or direct flights

```json
{
  "origin": "LAX",
  "destination": "MEX",
  "departureDate": "2026-10-20",
  "directOnly": true,
  "maxPrice": 250,
  "targetPrice": 200,
  "airlines": ["AM", "DL"],
  "maxResultsPerSearch": 100
}
```

`maxPrice` excludes expensive results. `targetPrice` keeps all matching results but marks fares at or below the threshold, which is useful for alerts and automations.

### Input reference

#### Route

| Input | Type | Description |
| --- | --- | --- |
| `origin` | string | Required three-letter origin IATA code |
| `destination` | string | Required three-letter destination IATA code |
| `departureDate` | string | Required date in `YYYY-MM-DD` format |
| `returnDate` | string | Optional return date for round trips |
| `departureDateEnd` | string | Optional final date for a flexible-date scan |
| `additionalRoutes` | array | Additional origin, destination, departure, and optional return dates |

#### Travelers and filters

| Input | Default | Description |
| --- | --- | --- |
| `cabinClass` | `economy` | Economy, premium economy, business, or first |
| `adults` | `1` | Adult passengers |
| `children` | `0` | Child passengers |
| `infantsInSeat` | `0` | Infants occupying seats |
| `infantsOnLap` | `0` | Lap infants |
| `directOnly` | `false` | Return only nonstop flights |
| `maxStops` | any | Maximum accepted stops from 0 to 3 |
| `airlines` | `[]` | Optional airline IATA codes |
| `maxPrice` | none | Maximum total displayed fare |
| `targetPrice` | none | Threshold used by `belowTargetPrice` |
| `maxResultsPerSearch` | `100` | Maximum itinerary rows per route/date search |

#### Locale and reliability

| Input | Default | Description |
| --- | --- | --- |
| `currency` | `USD` | Three-letter ISO currency code |
| `language` | `en-US` | Google result language |
| `includeRouteSummary` | `true` | Save fare statistics for every search |
| `maxConcurrency` | `2` | Parallel searches, maximum 5 |
| `requestDelayMs` | `500` | Delay between search starts |
| `proxyConfiguration` | disabled | Optional Apify proxy settings for high-volume runs |
| `debugMode` | `false` | Log transport and response diagnostics |

For recurring bulk monitoring, an Apify residential proxy and conservative concurrency improve resilience.

### Example output

```json
{
  "recordType": "flight",
  "itineraryId": "8aa6a26692678c4b073c",
  "rank": 1,
  "price": 247,
  "currency": "USD",
  "pricePerTraveler": 247,
  "priceTier": "lowest",
  "belowTargetPrice": true,
  "airlines": ["Delta"],
  "airlineCode": "DL",
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-10-15",
  "returnDate": null,
  "departureAt": "2026-10-15T08:10:00",
  "arrivalAt": "2026-10-15T11:28:00",
  "durationMinutes": 378,
  "stops": 0,
  "isDirect": true,
  "cabinClass": "economy",
  "carbonGrams": 412000,
  "googleFlightsUrl": "https://www.google.com/travel/flights?...",
  "scrapedAt": "2026-09-07T10:00:00.000Z"
}
```

Fields depend on what Google exposes for a particular itinerary. Optional values may be `null` or empty.

### Flight price monitoring and alerts

1. Save a task with your routes, dates, cabin, and `targetPrice`.
2. Schedule the task hourly, daily, or weekly in Apify Console.
3. Filter dataset rows where `recordType` is `flight` and `belowTargetPrice` is `true`.
4. Send matching rows to Slack, email, a webhook, Make, Zapier, or n8n.
5. Use `itineraryId` to compare the same itinerary across runs. IDs no longer include the price as of September 14, 2026; establish a fresh baseline when migrating older snapshots. The same schedule and airlines retain the same ID when the fare changes.

Airfares and availability change frequently. A result represents the fare visible when the Actor ran; it is not a reservation or price guarantee.

### Run with the Apify API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/groupoject~google-flights-price-monitor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "origin": "JFK",
    "destination": "LAX",
    "departureDate": "2026-10-15",
    "targetPrice": 250
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('groupoject/google-flights-price-monitor').call({
  origin: 'JFK',
  destination: 'LAX',
  departureDate: '2026-10-15',
  maxResultsPerSearch: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('groupoject/google-flights-price-monitor').call(run_input={
    'origin': 'JFK',
    'destination': 'LHR',
    'departureDate': '2026-11-10',
    'returnDate': '2026-11-17',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Use cases

- Flight fare comparison and travel-search applications
- Airfare price trackers and price-drop alerts
- Corporate travel route benchmarking
- Travel agency and airline market intelligence
- Flexible-date deal discovery
- AI travel assistants and MCP workflows
- Route, airline, duration, and emissions analysis
- Newsletter or community flight-deal feeds

### Reliability and responsible use

This Actor reads publicly accessible Google Flights search data. Google can change its response format, rate limits, available fields, or displayed fares without notice. The Actor retries transient failures and isolates individual route errors so one failed search does not discard successful routes.

Use the data responsibly and comply with applicable website terms, laws, and regulations. Do not treat scraped fare data as a confirmed booking. Travelers must verify current price, availability, baggage rules, visa requirements, and itinerary details with the airline or booking provider before purchasing.

### FAQ

#### Does this require a Google Flights API key?

No. The Actor does not require a Google API key, Google account, or login.

#### Does it return live flight prices?

Each run performs a fresh search. Prices reflect what Google Flights returned at that moment and may change afterward.

#### Can it search round-trip flights?

Yes. Add `returnDate`. The itinerary may contain outbound and return segments depending on the response Google exposes.

#### Can it find the cheapest travel day?

Yes. Set `departureDateEnd` to scan every departure date in a range of up to 31 days, then compare route summaries or rank all flight rows by price.

#### Can I search multiple airports or routes?

Yes. Add up to 50 entries in `additionalRoutes`. Use airport IATA codes such as `JFK`, `EWR`, `LGA`, `LHR`, or `LGW` as separate routes when comparing nearby airports.

#### Does it provide a Google Flights link?

Every record includes the reproducible Google Flights search URL. The Actor does not book travel or guarantee a provider checkout URL.

#### Why did a search return no flights?

Possible causes include invalid or unsupported airport/date combinations, no matching flights, filters that are too strict, temporary throttling, or a changed Google response. Try fewer filters, lower concurrency, or an Apify residential proxy.

#### How should I schedule fare alerts?

Create an Apify task with a target price, schedule it, and connect successful runs to a webhook or automation platform. Select rows where `belowTargetPrice` is true.

### Support

Open an issue from the Actor page with the route, travel dates, locale, and run ID. Do not include private account credentials or payment details.

### Pricing and billing

Base result price checked September 14, 2026: **$2.00 per 1,000 dataset items** ($0.002 each). 100 result items cost $0.20 in result fees.

The separate Actor start event is $0.01 per billable start unit, with one unit per GB of configured memory and a minimum of one. It applies even when a run returns no results.

Both flight rows and optional route\_summary rows are dataset items. A search returning 10 flights plus one summary creates 11 result events. Disable includeRouteSummary when only flight rows are needed.

The [live Pricing tab](https://apify.com/groupoject/google-flights-price-monitor/pricing) is authoritative for current rates, tier discounts and any separately charged usage. Set a maximum run charge and inspect a small sample before scaling. Charges from an external provider, where used, are not controlled by the Apify run-charge limit.

# Actor input Schema

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

Three-letter IATA airport code, for example JFK, LHR, CDG, DXB, or CMN.

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

Three-letter IATA airport code.

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

Travel date in YYYY-MM-DD format.

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

Optional. Adding a return date creates a round-trip search.

## `departureDateEnd` (type: `string`):

Optional end date. The Actor searches every departure date in the range, up to 31 days.

## `additionalRoutes` (type: `array`):

Bulk-search up to 50 more routes in the same run.

## `cabinClass` (type: `string`):

Fare cabin to search.

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

Number of adult travelers.

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

Number of child travelers.

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

Number of infants traveling in their own seats.

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

Number of lap infants.

## `directOnly` (type: `boolean`):

Return only nonstop itineraries.

## `maxStops` (type: `integer`):

Maximum number of connections accepted.

## `airlines` (type: `array`):

Optional IATA airline codes such as AA, DL, BA, or AT.

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

Exclude itineraries above this total fare in the selected currency.

## `targetPrice` (type: `number`):

Marks results at or below your target with belowTargetPrice=true.

## `maxResultsPerSearch` (type: `integer`):

Maximum itinerary records saved for each route and date.

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

Three-letter ISO currency code.

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

Google language code, for example en-US, fr, de, or ar.

## `includeRouteSummary` (type: `boolean`):

Adds one summary row per search with lowest, median and direct-flight prices.

## `maxConcurrency` (type: `integer`):

Maximum route searches running at the same time.

## `requestDelayMs` (type: `integer`):

Minimum delay between starting route searches.

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

Optional. Enable an Apify residential proxy if Google limits a recurring or high-volume search.

## `debugMode` (type: `boolean`):

Write transport diagnostics to the run log.

## Actor input object example

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departureDate": "2026-10-15",
  "additionalRoutes": [],
  "cabinClass": "economy",
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "directOnly": false,
  "airlines": [],
  "maxResultsPerSearch": 100,
  "currency": "USD",
  "language": "en-US",
  "includeRouteSummary": true,
  "maxConcurrency": 2,
  "requestDelayMs": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debugMode": false
}
```

# Actor output Schema

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

Ranked flight itineraries and route-level price summaries.

## `summary` (type: `string`):

Search counts, result totals, and per-route errors.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("groupoject/google-flights-price-monitor").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 = { "proxyConfiguration": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("groupoject/google-flights-price-monitor").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 '{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call groupoject/google-flights-price-monitor --silent --output-dataset

```

## MCP server setup

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

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/3piLOAX6l8jl9BZkE/builds/HqUmDNolhVFnEfhZe/openapi.json