# Google Flights Scraper - Fares, Price Calendar & Insights (`lagenuina_agency/google-flights-scraper`) Actor

Scrape Google Flights fares for any route and date: price, airlines, flight numbers, stops, layovers, times, aircraft, CO2, price level and history, price calendar, return flights, booking links. From $0.08/1K rows.

- **URL**: https://apify.com/lagenuina_agency/google-flights-scraper.md
- **Developed by:** [Quelli di Carne Genuina](https://apify.com/lagenuina_agency) (community)
- **Categories:** Travel, E-commerce, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 1,000 flight rows

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/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 - Fares, Price Calendar & Insights

Get **flight prices from Google Flights** for any route and date: fare, airlines, flight numbers, stops, layovers, departure and arrival times, duration, aircraft, legroom, **CO2 emissions**, Google's **price level** (low / typical / high) with ~60-day **price history**, a **price calendar** (cheapest fare per day), **return flights** for round trips and a **booking link** for every itinerary. One-way and round trip, economy to first, batch routes in one run. No Google account, no browser, no cookies.

> Independent tool, not affiliated with Google LLC. It reads the public fares shown on google.com/travel/flights.

### What you get

One row per itinerary (real result, shortened):

```json
{
  "type": "flight",
  "origin": "MXP",
  "destination": "JFK",
  "departureDate": "2026-12-10",
  "returnDate": "2026-12-17",
  "tripType": "round_trip",
  "rank": 1,
  "isBest": true,
  "price": 709,
  "currency": "EUR",
  "airlines": ["Vueling", "LEVEL"],
  "flightNumbers": ["VY 6045", "LL 2627"],
  "departureTime": "2026-12-10T15:10",
  "arrivalTime": "2026-12-10T22:00",
  "durationMinutes": 770,
  "stops": 1,
  "layovers": [{ "airport": "BCN", "city": "Barcelona", "durationMinutes": 120, "changeOfAirport": false }],
  "priceInsights": { "lowestPrice": 709, "typicalPriceLow": 510, "typicalPriceHigh": 960, "priceLevel": "typical" },
  "returnFlights": [{ "flightNumbers": ["LL 2628", "VY 6046"], "departureTime": "2026-12-17T23:45", "totalPrice": 709, "bookingUrl": "https://www.google.com/travel/flights/booking?tfs=…" }]
}
```

**Try it in 1 click: the prefilled example runs in seconds.** Press *Start* with the prefilled input (London Heathrow → New York JFK, 30 days from today): in our test today it finished in 4 seconds at 512 MB with 21 itineraries, a cost of about $0.003 on the Apify Free plan.

**Price:** from $0.16 per 1,000 rows on the Apify Free plan down to $0.08 on Gold and above. Price insights, return flights and booking links included, no start fee.

### Why this Google Flights scraper

- **20% cheaper on every Apify plan** than the most used Google Flights actor at today's prices ($0.16 vs $0.20 per 1,000 rows on Free, $0.08 vs $0.10 on Gold and above). That actor has announced a price of $0.70–$1.00 per 1,000 rows from 27 October 2026.
- **Works on the cheap Apify datacenter proxy**: no residential proxy needed, which keeps runs fast and cheap.
- **Built for reliability**: every page is retried on a fresh IP, one failing route never fails the run (it becomes a free `type: "error"` row), and a `RUN_SUMMARY` record tells you what happened on each route.
- **Drop-in compatible**: `origin`, `destination`, `departureDate`, `returnDate`, `adults`, `children`, `infantsInSeat`, `infantsOnLap`, `cabinClass`, `maxStops`, `currency`, `market`, `language`, `maxResults`, `sortBy`, `routes`, `airlines`, `excludeAirlines`, `maxPrice`, time windows, `calendarDays`, `calendarOnly`, `includePriceInsights`, `resolveReturnFlights` work with the same names as in the popular Google Flights actor.
- **Ready for monitoring**: relative dates (`"30 days"`) so scheduled runs always look the same distance ahead.

### Who uses it

- **Travel agencies, OTAs and travel startups**: live fares for any route, cabin and passenger mix.
- **Fare-alert and deal sites**: price calendar plus Google's own low / typical / high verdict and price history.
- **Corporate travel and finance teams**: benchmark booked fares against the market.
- **Researchers and AI agents**: "What does a nonstop London–New York flight cost in December?" answered with fresh data, CO2 included.

### Input

```json
{
  "origin": "MXP",
  "destination": "JFK",
  "departureDate": "2026-12-10",
  "returnDate": "2026-12-17",
  "adults": 2,
  "cabinClass": "economy",
  "maxStops": "1",
  "currency": "EUR",
  "market": "IT",
  "sortBy": "price",
  "calendarDays": 30,
  "resolveReturnFlights": true
}
```

| Field | What it does |
|---|---|
| `origin` / `destination` | 3-letter IATA airport code (`JFK`, `LHR`, `MXP`). |
| `departureDate` / `returnDate` | `YYYY-MM-DD` or days from today (`"30 days"`). No `returnDate` = one way. |
| `routes` | Batch: list of `{origin, destination, departureDate, returnDate}`. |
| `adults`, `children`, `infantsInSeat`, `infantsOnLap` | Up to 9 passengers; prices are the total for all of them. |
| `cabinClass` | `economy`, `premium_economy`, `business`, `first`. |
| `maxStops` | `any`, `0` (nonstop), `1`, `2`. |
| `currency`, `market`, `language` | Any ISO currency, point-of-sale country and language. |
| `sortBy`, `maxResults` | `best` (Google's order), `price`, `duration`, `departure`; rows per search. |
| `airlines`, `excludeAirlines` | IATA airline codes, e.g. `BA`, `AA`. |
| `maxPrice`, `maxDurationMinutes`, `maxLayoverMinutes`, `departureTimeFrom/To`, `arrivalTimeFrom/To` | Filters; filtered itineraries are not charged. |
| `includePriceInsights` | Price level, typical range and price history on every row (default on). |
| `calendarDays`, `calendarOnly` | Cheapest fare for each of the next N departure days (same trip length for round trips). |
| `resolveReturnFlights`, `maxReturnResolutions`, `maxReturnOptions` | Round trips: return flights for the top outbound itineraries, with total price and booking link. |

### Output

Flight rows (`type: "flight"`) carry, besides the fields above: `airlineCode`, `departureAirport`, `arrivalAirport`, `legs` (each flight with airline, flight number, airports and names, times, duration, aircraft, legroom, overnight, codeshares, CO2), `co2EmissionsKg`, `typicalCo2EmissionsKg`, `co2DifferencePct`, `emissionsTag` (lower / typical / higher), `selfTransfer`, `codeshareAirlines`, `priceInsights.priceHistory` (`[{date, price}]`), `bookingUrl` (one-way) and `googleFlightsUrl`.

Price calendar rows (`type: "calendarDay"`):

```json
{ "type": "calendarDay", "origin": "MXP", "destination": "JFK", "departureDate": "2026-12-10", "returnDate": "2026-12-17", "currency": "EUR", "lowestPrice": 709, "cheapestAirlines": ["Vueling", "LEVEL"], "cheapestStops": 1, "cheapestDurationMinutes": 770, "itinerariesFound": 9 }
```

Times are local to each airport (`YYYY-MM-DDTHH:mm`). Round-trip `price` is the total for both directions. The dataset has two views, *Flights* and *Price calendar*.

### Pricing

Pay per row: one itinerary or one calendar day. Price insights, return flights and booking links are included.

| Apify plan | Per 1,000 rows until Oct 26, 2026 | Per 1,000 rows from Oct 27, 2026 |
|---|---|---|
| Free | $0.16 | $0.80 |
| Bronze | $0.128 | $0.72 |
| Silver | $0.104 | $0.64 |
| Gold, Platinum, Diamond | $0.08 | $0.56 |

From October 27, 2026 prices stay 20% below the leading Google Flights scraper's announced new price list.

No start fee, no search fee, no proxy fee. Error rows and filtered itineraries are free. Set a maximum charge per run to cap spending: the scraper stops cleanly when it is reached.

### Migrating from lergassy/google-flights-scraper

The input field names are the same, so an existing input usually works after changing the actor ID to `lagenuina_agency/google-flights-scraper`.

| lergassy input | This actor | Notes |
|---|---|---|
| `origin`, `destination`, `departureDate`, `returnDate` | same | Relative dates like `"30 days"` also work. |
| `adults`, `children`, `infantsInSeat`, `infantsOnLap`, `cabinClass`, `maxStops` | same | |
| `currency`, `market`, `language`, `maxResults`, `sortBy` | same | |
| `routes`, `airlines`, `excludeAirlines`, `maxPrice`, `maxDurationMinutes`, `maxLayoverMinutes`, time windows | same | |
| `calendarDays`, `calendarOnly`, `includePriceInsights` | same | Calendar = one search per day. |
| `resolveReturnFlights`, `maxReturnResolutions`, `maxReturnOptions` | same | |
| `multiCityLegs`, `exploreAnywhere`, `resolveBookingOptions`, `fillMissingPricesFromKayak`, `dataSource` | not supported | See limits below. |

**Output:** core fields have the same meaning (`price`, `currency`, `airlines`, `flightNumbers`, `departureTime`, `arrivalTime`, `durationMinutes`, `stops`, `layovers`, `legs`, CO2, `priceInsights`, `bookingUrl`). Compare one row of each actor before switching a production pipeline: some field names may differ.

**Price per 1,000 rows** (public Apify Store prices, checked on 17 October 2026; both actors price by Apify plan):

| Apify plan | lergassy today | lergassy from 27 Oct 2026 | This actor |
|---|---|---|---|
| Free | $0.20 | $1.00 | $0.16 |
| Bronze | $0.16 | $0.90 | $0.128 |
| Silver | $0.13 | $0.80 | $0.104 |
| Gold and above | $0.10 | $0.70 | $0.08 |

Completeness: lergassy reads Google's results API through residential proxies and can return 100–150 itineraries per search; this actor reads the results page (see limits). Run the same input on both and compare.

### Limits / not supported

- **Itineraries per search: what Google's results page shows**, typically 8–60 (top flights plus "other flights"), not the full "View more flights" list.
- No multi-city trips, no "Explore anywhere" destinations, no per-seller booking options (Expedia, Kiwi…) and no Kayak fallback.
- Round-trip rows are outbound itineraries with the round-trip total; turn on `resolveReturnFlights` for the matching returns and their booking links.
- The price calendar runs one search per day (5 in parallel): 60 days = 60 rows.
- Fares are the ones Google shows for the chosen `market` and `currency`; when Google shows no price for an itinerary, `price` is `null`.
- `maxPrice`, duration and time-window filters are applied after reading the page; stops, airlines and max layover are sent to Google.

### Use it from AI agents (MCP)

Any MCP client (Claude, ChatGPT, Cursor, custom agents) can call this scraper through the Apify MCP server:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com/?actors=lagenuina_agency/google-flights-scraper" }
  }
}
```

Ask things like *"Cheapest nonstop flight Milan to New York in the second week of December, in euros"* or *"Which day next month is cheapest to fly London to Dubai?"*: inputs map directly to route, dates, passengers, cabin and filters, and results come back as clean JSON.

### Integrations and API

Call it from your code with the official Apify clients:

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lagenuina_agency/google-flights-scraper").call(run_input={"origin": "LHR", "destination": "JFK", "departureDate": "30 days", "currency": "USD"})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["price"], item["airlines"], item["departureTime"])
```

```js
// npm i apify-client
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lagenuina_agency/google-flights-scraper').call({ origin: 'LHR', destination: 'JFK', departureDate: '30 days', currency: 'USD' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

No-code: use the Apify app in **n8n**, **Make** or **Zapier** (action "Run Actor", pick `lagenuina_agency/google-flights-scraper`), or the `langchain-apify` / CrewAI `ApifyActorsTool` integrations for AI agents. Results can also go to Google Sheets, Slack, webhooks or S3 via Apify integrations.

Ready-to-run examples (Python, JavaScript, n8n workflow): [github.com/assa83/google-flights-api](https://github.com/assa83/google-flights-api).

### More tools from Quelli di Carne Genuina

**Ad intelligence**

- [Google Ads Transparency Scraper](https://apify.com/lagenuina_agency/google-ads-transparency-scraper): every ad a brand or domain runs on Google Search, YouTube, Shopping, Maps and Play.
- [Meta Ad Library Scraper](https://apify.com/lagenuina_agency/meta-ad-library-scraper): Facebook and Instagram ads by page, keyword or Ad Library URL, with creatives and landing pages.
- [TikTok Top Ads Scraper](https://apify.com/lagenuina_agency/tiktok-top-ads-scraper): top-performing TikTok ads from the Creative Center with CTR, likes and MP4 video URLs.
- [LinkedIn Ad Library Scraper](https://apify.com/lagenuina_agency/linkedin-ad-library-scraper): B2B ads of any company from the public LinkedIn Ad Library, with targeting and impressions.

**Competitor & SEO research**

- [Similarweb Website Traffic Scraper](https://apify.com/lagenuina_agency/similarweb-scraper): monthly visits, ranks, traffic sources and top countries for any list of domains.
- [Google Trends Scraper](https://apify.com/lagenuina_agency/google-trends-scraper): interest over time, by region, related queries and Trending Now.
- [Google Play Store Scraper](https://apify.com/lagenuina_agency/google-play-scraper): app search, details, top charts and reviews from Google Play, any country.

**Travel prices**

- [Google Hotels Scraper](https://apify.com/lagenuina_agency/google-hotels-scraper): hotel prices for the same trip, with every booking site's rate (Booking.com, Expedia, official site).

**Retail prices**

- [Woolworths AU Product Scraper](https://apify.com/lagenuina_agency/woolworths-scraper): Woolworths Australia grocery prices, specials, unit prices and barcodes.
- [Coles AU Product Scraper](https://apify.com/lagenuina_agency/coles-scraper): Coles Australia grocery prices, half-price specials, unit prices and barcodes.

**Content & social data**

- [YouTube Transcript Scraper](https://apify.com/lagenuina_agency/youtube-transcript-scraper): transcripts of videos, Shorts, playlists and channels as text, SRT or VTT.
- [Medium Scraper](https://apify.com/lagenuina_agency/medium-scraper): Medium articles by tag, author or search, with full text as Markdown.
- [Likee Scraper](https://apify.com/lagenuina_agency/likee-scraper): Likee videos, profiles and creator engagement analytics.

### FAQ

**Is there a Google Flights API?**
Google shut down its public flight API (QPX Express) in 2018. This actor gives you Google Flights fares as JSON through the Apify API, from Python, JavaScript, n8n, Make, Zapier or MCP.

**How do I get the cheapest flight for a route and date?**
Set `origin`, `destination`, `departureDate` and `sortBy: "price"`. The first row is the cheapest itinerary Google shows.

**How do I find the cheapest day to fly?**
Set `calendarDays` (e.g. 30) and `calendarOnly: true`: you get one row per departure day with its lowest fare.

**Are Google Flights prices for all passengers?**
Yes, `price` is the total for all passengers, and for round trips the total for both directions.

**Does it show if prices are low or high right now?**
Yes, `priceInsights.priceLevel` is Google's low / typical / high verdict, with the typical price range and recent price history.

**Can I track flight prices over time?**
Schedule the actor with relative dates (`"60 days"`) and compare `price` or `priceInsights.lowestPrice` between runs.

**Which currencies and countries are supported?**
Any currency Google Flights supports (USD, EUR, GBP, INR, JPY…) and any point-of-sale country via `market`.

**Do I need proxies or a Google account?**
No account. The default Apify Proxy (datacenter) works; failed pages are retried automatically on a new IP.

**Something broke?**
Open an issue on the Issues tab: we answer within 24 hours.

# Actor input Schema

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

3-letter IATA airport code, e.g. <code>JFK</code>, <code>LHR</code>, <code>MXP</code>. Required unless you fill <b>routes</b> (empty input runs a demo search LHR → JFK).

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

3-letter IATA airport code, e.g. <code>JFK</code>, <code>CDG</code>, <code>BKK</code>.

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

<code>YYYY-MM-DD</code>, or days from today like <code>30 days</code> (handy for scheduled runs). Empty = 30 days from today.

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

Leave empty for one-way. <code>YYYY-MM-DD</code> or days from today. Round-trip prices are the total for both directions.

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

Search many routes in one run. Each item: <code>{"origin": "LHR", "destination": "JFK", "departureDate": "2026-12-10", "returnDate": "2026-12-17"}</code>. When set, the single route above is ignored.

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

Passengers aged 12+. Prices are the total for all passengers (max 9 passengers in all).

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

Aged 2–11.

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

Under 2, with their own seat.

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

Under 2, on an adult's lap.

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

Economy, premium economy, business or first.

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

ISO code for prices: <code>USD</code>, <code>EUR</code>, <code>GBP</code>, <code>INR</code>…

## `market` (type: `string`):

Two-letter country code, e.g. <code>US</code>, <code>GB</code>, <code>IT</code>, <code>DE</code>. Fares can differ by country.

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

Language of airport and airline names, e.g. <code>en</code>, <code>it</code>, <code>de</code>.

## `maxStops` (type: `string`):

<code>any</code>, <code>0</code> nonstop only, <code>1</code> up to one stop, <code>2</code> up to two stops.

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

Google's own ranking (best), or by price, duration or departure time.

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

Upper limit of flight rows per route.

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

IATA airline codes to keep, e.g. <code>BA</code>, <code>AA</code>. Empty = all.

## `excludeAirlines` (type: `array`):

IATA airline codes to drop, e.g. <code>FR</code>.

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

Drop flights above this price (selected currency).

## `maxDurationMinutes` (type: `integer`):

e.g. <code>720</code> for 12 hours.

## `maxLayoverMinutes` (type: `integer`):

Drop itineraries with any layover longer than this.

## `departureTimeFrom` (type: `string`):

Earliest local departure time, e.g. <code>06:00</code>.

## `departureTimeTo` (type: `string`):

Latest local departure time, e.g. <code>12:00</code>.

## `arrivalTimeFrom` (type: `string`):

Earliest local arrival time.

## `arrivalTimeTo` (type: `string`):

Latest local arrival time.

## `includePriceInsights` (type: `boolean`):

Add Google's price level (low / typical / high), typical price range and ~60-day price history to every flight row.

## `calendarDays` (type: `integer`):

Lowest fare for each departure date over this many days starting at the departure date (round trips keep the same trip length). One extra search per day. <code>0</code> = off.

## `calendarOnly` (type: `boolean`):

Return only the price calendar rows: the cheapest way to sweep dates.

## `resolveReturnFlights` (type: `boolean`):

Round trips: for the top outbound itineraries, fetch the list of return flights (with total price and a booking link for each pair). One extra search per outbound.

## `maxReturnResolutions` (type: `integer`):

How many top outbound itineraries get their return flights.

## `maxReturnOptions` (type: `integer`):

Cheapest first.

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

Apify datacenter proxy works for Google Flights; keep the default.

## `requestTimeoutSecs` (type: `integer`):

Per page request.

## Actor input object example

```json
{
  "origin": "LHR",
  "destination": "JFK",
  "departureDate": "30 days",
  "adults": 1,
  "children": 0,
  "infantsInSeat": 0,
  "infantsOnLap": 0,
  "cabinClass": "economy",
  "currency": "USD",
  "market": "US",
  "language": "en",
  "maxStops": "any",
  "sortBy": "best",
  "maxResults": 100,
  "includePriceInsights": true,
  "calendarDays": 0,
  "calendarOnly": false,
  "resolveReturnFlights": false,
  "maxReturnResolutions": 10,
  "maxReturnOptions": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestTimeoutSecs": 40
}
```

# Actor output Schema

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

No description

## `summary` (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": "LHR",
    "destination": "JFK",
    "departureDate": "30 days",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lagenuina_agency/google-flights-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": "LHR",
    "destination": "JFK",
    "departureDate": "30 days",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lagenuina_agency/google-flights-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": "LHR",
  "destination": "JFK",
  "departureDate": "30 days",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lagenuina_agency/google-flights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lagenuina_agency/google-flights-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/z86dxl2HFnOdSJNUb/builds/ENVpQu9ncorBUnzLU/openapi.json