# Google Flights Search Scraper (`solidcode/google-flights-scraper`) Actor

\[💰 $60 / 1K searches] Search Google Flights for one-way, round-trip, and multi-city trips. Filter by price, stops, and airlines, pull direct booking links from airlines and travel agencies, and get every result as clean, ready-to-use data.

- **URL**: https://apify.com/solidcode/google-flights-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 41 total users, 3 monthly users, 94.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.
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 Search Scraper

Extract real-time flight prices, airlines, schedules, and routes from Google Flights at scale. Search one-way, round-trip, or complex multi-city itineraries with full control over passengers, filters, currency, and locale — and get clean, structured JSON every time.

### Why This Scraper?

- **Full trip-type coverage** — One-way, round-trip, and multi-city searches with 2+ legs all in a single actor
- **Multi-airport support** — Search across several origin or destination airports at once (e.g. `CDG,ORY` or `JFK,LGA,EWR`)
- **Rich flight details** — Price, airline, flight number, aircraft type, departure and arrival times, layovers, total duration, and stop count for every leg
- **Party-total pricing** — Every price covers all passengers in the search combined, so a 2-adult, 2-child query returns the real family total instead of a single-seat teaser fare
- **Powerful filters** — Cap maximum price, restrict to specific airlines, limit stops (nonstop only, up to 1 stop, up to 2), and hide basic economy fares
- **29 languages × 39 countries × 20 currencies** — Pull results the way your target traveller sees them
- **Price insights included** — First-page results tell you whether the current price is low, typical, or high versus the historical average, plus the lowest price available
- **Airport directory** — Every referenced airport comes back with full name, city, and country — no extra lookups needed
- **Non-technical input** — Friendly labels and dropdowns for languages, countries, currencies, and stop limits; no need to remember Google's internal codes

### Use Cases

**Travel & Fare Monitoring**

- Track prices on specific routes over time to identify the best booking windows
- Monitor competitor fares for OTA and metasearch pricing strategies
- Build fare alert systems that notify users when prices drop

**Travel Agencies & OTAs**

- Compare airline offers across multiple routes and dates in seconds
- Populate search results for travel booking sites and mobile apps
- Feed live fare data into CRM systems for personalised customer offers

**Market Research & Analytics**

- Analyse price trends between city pairs, seasons, or airlines
- Study how fares shift across currencies, booking country, or trip type
- Benchmark basic economy vs. main cabin pricing across carriers

**Corporate Travel & Expense Management**

- Audit booked fares against live market prices for policy compliance
- Surface cheaper alternatives for frequent business routes
- Build internal dashboards comparing travel spend to real-time market rates

**Product Development & Data Enrichment**

- Enrich itinerary databases with live pricing, durations, and layover details
- Power route-planning tools with accurate multi-city trip data
- Feed ML models with structured historical fare and availability signals

### Getting Started

#### Simple One-Way Search

The minimum input — origin, destination, and a date:

```json
{
    "departureAirports": "LAX",
    "arrivalAirports": "JFK",
    "outboundDate": "2026-08-15"
}
```

#### Round-Trip with Passengers

Add a return date to run a round-trip search:

```json
{
    "departureAirports": "SFO",
    "arrivalAirports": "SEA",
    "outboundDate": "2026-09-10",
    "returnDate": "2026-09-17",
    "adults": 2,
    "children": 1
}
```

Every price that comes back covers all three passengers together, not one seat.

#### Filtered Search

Cap price, limit stops, and restrict to specific airlines:

```json
{
    "departureAirports": "LHR",
    "arrivalAirports": "JFK,EWR",
    "outboundDate": "2026-10-05",
    "returnDate": "2026-10-19",
    "maxPrice": 800,
    "maxStops": "0",
    "airlines": "BA,AA,VS",
    "excludeBasicEconomy": true,
    "currency": "GBP",
    "country": "uk",
    "language": "en"
}
```

#### Multi-City Itinerary

Build a custom multi-leg trip by listing each leg:

```json
{
    "multiCityLegs": [
        { "departureAirports": "LAX", "arrivalAirports": "JFK", "date": "2026-07-10" },
        { "departureAirports": "JFK", "arrivalAirports": "MIA", "date": "2026-07-15" },
        { "departureAirports": "MIA", "arrivalAirports": "LAX", "date": "2026-07-22" }
    ],
    "adults": 1,
    "currency": "USD"
}
```

When `multiCityLegs` is provided, the simple route fields above are ignored.

### Input Reference

#### Route

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `departureAirports` | string | `LAX` | IATA airport codes to depart from, comma-separated (e.g. `LAX` or `CDG,ORY`). Clearing the field stops the run rather than searching a different route |
| `arrivalAirports` | string | `JFK` | IATA airport codes to arrive at, comma-separated (e.g. `JFK` or `LAX,SEA`). Clearing the field stops the run rather than searching a different route |
| `outboundDate` | string | 30 days out | Departure date in `YYYY-MM-DD` format. Leave it empty and the search runs 30 days from today |
| `returnDate` | string | | Return date in `YYYY-MM-DD`. Set this for a round-trip; leave empty for one-way |
| `multiCityLegs` | array | `[]` | Multi-city itinerary legs. Each leg has `departureAirports`, `arrivalAirports`, and `date`. Overrides the simple route fields when set |

#### Passengers

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `adults` | integer | `1` | Adult passengers (age 12+). Minimum 1 |
| `children` | integer | `0` | Child passengers (ages 2–11) |
| `infants` | integer | `0` | Infant passengers (under 2) |

Prices in the results are always the total for everyone in the search combined. Two adults plus two children means every `price` you get back is the four-passenger total, not a per-seat fare.

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxPrice` | integer | no limit | Only return flights at or below this price, in the chosen currency. Measured against the all-passenger total, not the per-person fare — a 4-passenger search needs roughly 4× the per-seat budget. Leave it empty for no limit; `0` is refused up front instead of returning nothing |
| `maxStops` | string | `""` | `""` = any number of stops, `"0"` = direct only, `"1"` = up to 1 stop, `"2"` = up to 2 stops |
| `airlines` | string | | Preferred airline IATA codes, comma-separated (e.g. `UA,AA,DL`) |
| `excludeBasicEconomy` | boolean | `false` | Hide basic economy fares (no free carry-on or seat selection) |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | string | `"USD"` | Currency for prices — 20 ISO 4217 codes supported (USD, EUR, GBP, CAD, AUD, JPY, CHF, INR, CNY, and more) |
| `language` | string | `"en"` | Result language — 29 options (English, Spanish, French, German, Chinese, Japanese, Arabic, Hindi, and more) |
| `country` | string | `"us"` | Country market Google searches from — 39 options. Affects available fares and airlines |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `fetchBookingOptions` | boolean | `false` | Include direct booking links with fare family and baggage details. One-way searches only. Each resolved link is billed separately |
| `maxPages` | integer | `1` | How many result batches to collect. Page 1 is the shortlist (20–35 flights); page 2 adds every remaining flight held behind Google's "show more flights" link, often 3–5× as many. Nothing exists after page 2 |

### Output

Each dataset item represents one page of results. Here's a trimmed example:

```json
{
    "search_parameters": {
        "tripType": "one-way",
        "legs": [
            { "departureAirports": ["LAX"], "arrivalAirports": ["JFK"], "date": "2026-08-15" }
        ],
        "passengers": { "adults": 1, "children": 0, "infants": 0 },
        "language": "en",
        "country": "us",
        "currency": "USD"
    },
    "search_metadata": {
        "total_flights_found": 25,
        "best_flights_count": 3,
        "other_flights_count": 22,
        "pages_processed": 1,
        "booking_options_count": 0
    },
    "search_timestamp": "2026-04-20T22:15:00+00:00",
    "page_number": 1,
    "best_flights": [
        {
            "price": 174,
            "airline": "B6",
            "airlineName": "JetBlue",
            "departureAirport": "LAX",
            "arrivalAirport": "JFK",
            "departureDate": "2026-08-15",
            "departureTime": "20:50",
            "arrivalDate": "2026-08-16",
            "arrivalTime": "05:25",
            "durationMinutes": 335,
            "stops": 0,
            "flightId": "OriFxc",
            "legs": [
                {
                    "airline": "B6",
                    "airlineName": "JetBlue",
                    "flightNumber": "424",
                    "aircraft": "Airbus A321",
                    "departureAirport": "LAX",
                    "arrivalAirport": "JFK",
                    "departureDate": "2026-08-15",
                    "departureTime": "20:50",
                    "arrivalDate": "2026-08-16",
                    "arrivalTime": "05:25",
                    "durationMinutes": 335
                }
            ],
            "bookingToken": "CjRIMXV1M21..."
        }
    ],
    "other_flights": [ "..." ],
    "price_insights": {
        "priceLevel": "high",
        "lowestPrice": 174,
        "typicalPrice": 139,
        "typicalPriceRange": [125, 190]
    },
    "airports": [
        { "code": "LAX", "name": "Los Angeles International Airport", "city": "Los Angeles", "country": "US" },
        { "code": "JFK", "name": "John F. Kennedy International Airport", "city": "New York", "country": "US" }
    ]
}
```

#### All Available Fields

**Top-level**

| Field | Type | Description |
|-------|------|-------------|
| `search_parameters` | object | Echo of the resolved search — trip type, routes, dates, passengers, language, country, currency |
| `search_metadata` | object | Aggregate stats — total flights found, best/other counts, pages processed, booking options count |
| `search_timestamp` | string | ISO-8601 timestamp of when this page was fetched |
| `page_number` | integer | 1-indexed page number |
| `best_flights` | object\[] | Google's top-recommended flights for this search |
| `other_flights` | object\[] | Additional flight options beyond the best picks |
| `price_insights` | object | First page only — tells you whether the current price is low, typical, or high versus history |
| `airports` | object\[] | First page only — full details for every airport referenced in the results |
| `booking_options` | object\[] | Populated only when `fetchBookingOptions=true` on a one-way search |

**Flight object**

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in the chosen currency for all passengers in the search combined, not per person |
| `airline` | string | Primary airline IATA code |
| `airlineName` | string | Full airline name |
| `departureAirport` | string | IATA code of the origin airport |
| `arrivalAirport` | string | IATA code of the final destination |
| `departureDate` | string | `YYYY-MM-DD` |
| `departureTime` | string | 24-hour local time (`HH:MM`) |
| `arrivalDate` | string | `YYYY-MM-DD` |
| `arrivalTime` | string | 24-hour local time (`HH:MM`) |
| `durationMinutes` | number | Total trip duration in minutes (including layovers) |
| `stops` | number | Number of stops (0 = nonstop) |
| `flightId` | string | Unique identifier for this flight option |
| `legs` | object\[] | Per-segment details (airline, flight number, aircraft, times, airports) |
| `bookingToken` | string | Token you can feed back into `fetchBookingOptions` to resolve direct booking links |

**Price insights**

| Field | Type | Description |
|-------|------|-------------|
| `priceLevel` | string | `"low"`, `"typical"`, or `"high"` compared to historical fares |
| `lowestPrice` | number | Lowest price currently available |
| `typicalPrice` | number | Typical price for this route at this time of year |
| `typicalPriceRange` | number\[] | `[min, max]` typical price band |

Like `price`, every figure here covers all passengers in the search combined, so it scales with your passenger count.

**Airport**

| Field | Type | Description |
|-------|------|-------------|
| `code` | string | IATA code (e.g. `LAX`) |
| `name` | string | Full airport name |
| `city` | string | City name |
| `country` | string | Country code |

### Tips for Best Results

- **Use future dates within the next 12 months** — Google Flights rarely returns results for dates more than a year out
- **Match currency and country to your use case** — a search with `country="uk"` and `currency="GBP"` shows fares and airlines as a UK traveller would see them, which can differ significantly from the US view
- **Leverage multi-airport search** — `JFK,LGA,EWR` as a single origin often surfaces cheaper or more convenient options than any single airport alone
- **Start with `maxStops="0"` for premium routes** — nonstop filters cut noise on busy business routes and reveal only the most attractive fares
- **Set `maxPages` to 2 when you want the whole market** — page 1 is the shortlist most travellers see, page 2 unlocks the full list (a New York to London search grows from 24 flights to 79); leave it at 1 when you only need the headline options
- **Budget `maxPrice` for the whole party, not one seat** — prices are all-passenger totals, so a family of four willing to pay $250 each should set `maxPrice` around 1000; setting it to 250 filters almost everything out
- **Combine `airlines` with `excludeBasicEconomy`** — perfect for corporate travel auditing or loyalty-program-aware fare monitoring

### Pricing

**From $0.06 per flight search — $60 per 1,000 searches** on the Gold tier. You pay a small fee when a run starts plus a fixed fee for each page of results collected. There are no compute or time-based charges, and pages that come back empty or fail are never charged.

One search covers one route and one date (or one multi-city itinerary) and returns 20–35 flights on the first page. Each search adds one row to your dataset holding every flight it found. Bronze, Silver, and Gold subscribers pay progressively less per page; the table shows the all-in cost of a default single-page search at each discount tier.

| Searches | No discount | Bronze | Silver | Gold |
|----------|-------------|--------|--------|------|
| 100 | $6.40 | $6.26 | $6.13 | $6.00 |
| 1,000 | $63.96 | $62.61 | $61.31 | $60.00 |
| 10,000 | $639.62 | $626.11 | $613.11 | $600.00 |
| 100,000 | $6,396.20 | $6,261.13 | $6,131.06 | $6,000.00 |

Discount tiers take effect on October 25, 2026. Until then every plan pays the Gold price shown above, and Gold stays at that price afterwards.

**You are billed per page, not per flight**, so the fuller the page, the less each flight costs (Gold prices):

| Setting | Flights per search | Cost per search | Cost per 1,000 flights |
|---------|--------------------|-----------------|------------------------|
| `maxPages: 1` (default) | 20–35 | $0.06 | $1.70–$3.00 |
| `maxPages: 2` (full market) | 79–135 | $0.08 | $0.60–$1.00 |

Collecting the second page costs a third more per search and typically returns three to five times as many flights, which makes it the cheaper way to buy volume.

**Booking links are the one costly option.** With `fetchBookingOptions` switched on for a one-way search, every resolved link is charged at $0.02 on Gold ($0.024 without a discount) and a typical search resolves 80–120 of them, adding roughly $1.60–$2.40 to that one search. Leave it off unless you need the direct booking URLs.

Figures above assume the default run size, and the start portion of the fee scales with it — a smaller run costs less to start.

### Integrations

Export results in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access to runs and datasets

### Legal & Ethical Use

This actor is designed for legitimate fare monitoring, travel research, pricing analysis, and data enrichment. Users are responsible for complying with applicable laws and Google's Terms of Service. The data returned is publicly available flight pricing — do not use it for spam, resale-as-inventory, or any deceptive purpose.

# Actor input Schema

## `departureAirports` (type: `string`):

IATA airport codes to depart from, comma-separated (e.g. 'LAX' or 'CDG,ORY'). Required unless you're using multi-city legs below — clearing this field stops the run rather than searching a different route.

## `arrivalAirports` (type: `string`):

IATA airport codes to arrive at, comma-separated (e.g. 'JFK' or 'LAX,SEA'). Required unless you're using multi-city legs below — clearing this field stops the run rather than searching a different route.

## `outboundDate` (type: `string`):

Departure date in YYYY-MM-DD format (e.g. 2026-06-15). Must be today or later. Leave empty to default to 30 days from today.

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

Return date in YYYY-MM-DD format, on or after the outbound date. Set this to run a round-trip search. Leave empty for one-way.

## `multiCityLegs` (type: `array`):

For multi-city itineraries, list each leg (at least 2). Each leg is an object with 'departureAirports', 'arrivalAirports' (comma-separated IATA codes), and 'date' (YYYY-MM-DD). All three are required on every leg — a leg missing one stops the run rather than being dropped, so you are never priced for a shorter trip than you entered. List the legs in the order you will fly them, earliest date first. When this is non-empty, the simple route fields above are ignored.

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

Number of adult passengers (age 12+). Minimum 1.

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

Number of child passengers (ages 2–11).

## `infants` (type: `integer`):

Number of infant passengers (under 2).

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

Only return flights at or below this price, in the chosen currency. This is checked against the total for all passengers in the search, not the price per person — with 4 passengers you need roughly 4x the per-seat budget. Leave empty for no limit — 0 is not a valid limit and the run will stop and tell you so.

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

Limit how many stops a flight can have. Choose 'Any number of stops' for no limit.

## `airlines` (type: `string`):

Limit results to these airlines. Use 2-character IATA airline codes, comma-separated (e.g. 'UA,AA,DL') — the code, not the airline's name, so 'DL' rather than 'Delta'. Anything else is refused straight away. Leave empty to include all airlines.

## `excludeBasicEconomy` (type: `boolean`):

Hide basic economy fares (fares without free carry-on or seat selection).

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

Currency used for prices (ISO 4217 code).

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

Language for the returned results.

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

Country market Google should search from — affects available fares and airlines.

## `fetchBookingOptions` (type: `boolean`):

When enabled, include direct booking links from each airline and travel agency, plus fare details and baggage info, for every flight returned. Only works for one-way searches (round-trip and multi-city will return an empty booking list). Each resolved booking link is billed separately — a typical one-way search produces 80–120 links, so costs can rise quickly.

## `maxPages` (type: `integer`):

How many batches of results to collect. Page 1 is the shortlist Google shows first (usually 20–35 flights). Page 2 adds every remaining flight Google keeps behind its 'show more flights' link, which is often 3–5× as many. There is nothing after page 2 — a search has only these two batches — so the run stops there and values above 2 collect nothing extra. Each flight is returned once, never repeated across pages.

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

Configure how requests are routed. The default uses Apify Proxy with datacenter IPs, which works for most users. Switch to residential IPs only if you see persistent failures.

## Actor input object example

```json
{
  "departureAirports": "LAX",
  "arrivalAirports": "JFK",
  "multiCityLegs": [],
  "adults": 1,
  "children": 0,
  "infants": 0,
  "excludeBasicEconomy": false,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "fetchBookingOptions": false,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of pages with key search parameters and result counts.

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

Expanded view of the best flights from each page. Prices are the total for all passengers in the search, not per person.

# 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 = {
    "departureAirports": "LAX",
    "arrivalAirports": "JFK",
    "multiCityLegs": [],
    "adults": 1,
    "children": 0,
    "infants": 0,
    "excludeBasicEconomy": false,
    "currency": "USD",
    "language": "en",
    "country": "us",
    "fetchBookingOptions": false,
    "maxPages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "departureAirports": "LAX",
    "arrivalAirports": "JFK",
    "multiCityLegs": [],
    "adults": 1,
    "children": 0,
    "infants": 0,
    "excludeBasicEconomy": False,
    "currency": "USD",
    "language": "en",
    "country": "us",
    "fetchBookingOptions": False,
    "maxPages": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "departureAirports": "LAX",
  "arrivalAirports": "JFK",
  "multiCityLegs": [],
  "adults": 1,
  "children": 0,
  "infants": 0,
  "excludeBasicEconomy": false,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "fetchBookingOptions": false,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/google-flights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solidcode/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/W8A7PMbQUtG3cCL0P/builds/6SOxZKS6F4Des4hhJ/openapi.json