canonical: https://jentic.com/apis/aviationstack.com/aviationstack

# Aviationstack API

The Aviationstack API returns real-time and historical aviation data drawn from a global network of airlines and airports. It reports live and scheduled flights, resolves routes between airports, and looks up airlines, airplanes, and aircraft types by their identifiers. It also serves place-reference data for airports, cities, and countries, along with aviation taxes and a forward timetable, so an agent can turn a flight number, route, or airport code into structured records. Every response is keyed to standard aviation identifiers such as IATA and ICAO codes, making the API a data layer for flight status, schedule, and airport lookups rather than a booking or ticketing system.

## For AI agents

Query aviation data: look up live and scheduled flights, routes, airlines, airplanes, aircraft types, and reference records for airports, cities, and countries.

## Scope

Does not handle ticket booking, seat selection, or flight payment. Use for flight, airline, and airport data lookups only.

## Capabilities

- Look up live and historical flight records filtered by flight number, airline, or route
- Resolve routes between a departure and arrival airport with their operating airlines
- Retrieve airline, airplane, and aircraft-type records by their aviation identifiers
- Fetch airport, city, and country reference records keyed to IATA and ICAO codes
- Read a forward flight timetable and future flight schedules for planning
- Return aviation tax records associated with routes and airports

## Use cases

### AI agent flight-status lookup

An AI travel or operations agent needs to answer live flight questions without scraping airline sites. Through Jentic the agent calls the Aviationstack API to pull a flight's live status, its route, and the operating airline, then reports departure and arrival details back to the user. Because the data is keyed to IATA and ICAO codes, the agent can chain a flight lookup into airport and airline reference calls to assemble a complete picture.

Example prompt: Search Jentic for 'check live flight status', then call GET /flights filtered by flight number and read the flight status, departure, and arrival fields from the response.

### Route and carrier discovery

A trip-planning workflow needs to know which airlines operate between two airports and what the typical routing looks like. The routes lookup resolves connections between a departure and arrival airport along with the carriers that fly them, so the workflow can present realistic options. Pairing it with the airlines lookup lets the workflow enrich each option with the operating carrier's details.

Example prompt: Call GET /routes with a departure and arrival IATA code, then call GET /airlines to enrich each returned carrier with its airline record.

### Airport and city reference enrichment

A data pipeline needs to normalise airport and city references against standard aviation codes. Using the airports, cities, and countries lookups, a workflow resolves an airport code to its city and country and validates identifiers across records. This keeps travel data consistent when it is joined against bookings, invoices, or itineraries from other systems.

Example prompt: Call GET /airports for a given IATA code, then call GET /cities and GET /countries to resolve the airport's city and country records.

### Forward schedule planning

A scheduling assistant needs upcoming flight options rather than live status. The timetable and future-flights lookups return scheduled departures and arrivals ahead of time, letting the assistant surface planning options for a given airport or route. This complements the live flights lookup when the user is planning rather than tracking.

Example prompt: Call GET /timetable for a departure airport, then call GET /flightsFuture to list scheduled flights for the planning window the user asked about.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/flights` | Look up live and historical flights |
| GET | `/routes` | Resolve routes between airports |
| GET | `/airlines` | Look up airline records |
| GET | `/airports` | Look up airport reference records |
| GET | `/cities` | Look up city reference records |
| GET | `/countries` | Look up country reference records |
| GET | `/timetable` | Read a forward flight timetable |
| GET | `/flightsFuture` | List future scheduled flights |

## Why Jentic

- **Setup:** Wiring the Aviationstack API by hand means threading the access_key query parameter onto every request and handling its per-plan quotas yourself. Through Jentic you install once, import it from the API Directory, store the access key once, and your agent calls it.
- **Permission scoping:** The Aviationstack API exposes read-only aviation lookups rather than resources your agent owns, so a rule bounds which of those operations it may call: live flights and routes, without the airlines, cities, or countries reference lookups unless you add them. You choose the allowed set, so the agent only runs the queries you pick.
- **Credential handling:** Your Aviationstack access key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'check live flight status' or 'find routes between two airports', and Jentic returns the matching Aviationstack operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **AviationData.Systems Airports** — AviationData.Systems resolves airport reference records that pair with Aviationstack's live flight data
- **Flightradar24** — Flightradar24 provides live aircraft tracking as an alternative source of flight position data
- **AirportData** — AirportData adds aircraft registration and airport metadata alongside Aviationstack's flight records
- **Airport Gap** — Airport Gap serves airport details and inter-airport distances that complement Aviationstack routes

## FAQ

### Is there an Aviationstack API MCP server?

You don't need an MCP server to give your agent the Aviationstack API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls the flight, route, and airport lookups on demand without loading another server's tool definitions into its context.

### What authentication does the Aviationstack API use?

The Aviationstack API authenticates with an apiKey passed as the access_key query parameter, per its OpenAPI spec. When you call it through Jentic, that access key is stored encrypted by your own Jentic One instance and injected at execution time, so it never appears in the agent's prompt or logs.

### Can I look up live flight status with the Aviationstack API?

Yes. The GET /flights endpoint returns live and historical flight records that you can filter by flight number, airline, or route, and each record carries the flight status along with departure and arrival details keyed to IATA and ICAO codes.

### What are the rate limits for the Aviationstack API?

The OpenAPI spec does not specify rate limits for the Aviationstack API. Aviationstack enforces per-plan monthly request quotas, so check the provider's documentation at https://aviationstack.com/documentation for the limits on your plan before running high-volume queries.

### How do I check a flight's status through Jentic?

Search Jentic for 'check live flight status', load the matching operation, and call GET /flights filtered by the flight number to read back its status and schedule. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Aviationstack API?

Yes. Because Jentic One is self-hosted, you decide which of the read-only lookups the agent may call: you might allow the flights and routes lookups while leaving out the airlines, cities, or countries reference calls, and every call the agent makes is logged.