Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@AirLabs MCP Server Is flight BA117 on time?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
This Model Context Protocol (MCP) server provides access to the AirLabs aviation data API. It lets AI assistants such as Claude Desktop and Cursor access real-time flight data, airport schedules, delays, and reference databases for airlines, airports, aircraft fleets and routes — directly through natural-language questions.
The entire server lives in a single file (index.ts): tool definitions, the AirLabs HTTP client, request handling and the stdio transport.
Live flight status — look up any flight by number and get status, gate, terminal and delay.
Airport schedules — departures and arrivals boards for any airport.
Delay monitoring — find flights delayed beyond a threshold at an airport or airline.
Real-time positions — live aircraft coordinates, altitude, speed and heading by area, airline or registration.
Nearest airport — closest airports to any coordinate.
Reference databases — airlines, airports, aircraft fleets (by tail number or ICAO24 hex) and route networks.
Code resolution — turn a place or airline name into its IATA/ICAO code.
Related MCP server: Flightradar24 MCP Server
Node.js 18.0.0 or higher.
AirLabs API key — get a free key at https://airlabs.co/signup.
npm install -g @airlabs-co/airlabs-mcpAdd this to your claude_desktop_config.json:
{
"mcpServers": {
"airlabs": {
"command": "npx",
"args": ["@airlabs-co/airlabs-mcp@latest"],
"env": {
"AIRLABS_API_KEY": "your_api_key_here"
}
}
}
}Notes:
Replace your_api_key_here with your actual AirLabs API key.
Restart Claude Desktop after editing the config.
If you build from source locally, use "command": "node", "args": ["/path/to/build/index.js"].
Run the server directly over stdio:
AIRLABS_API_KEY=your_api_key_here npx @airlabs/airlabs-mcpTool | AirLabs endpoint | Purpose |
|
| Live status of one flight by IATA/ICAO number |
|
| Departures / arrivals board for an airport |
|
| Flights delayed beyond a threshold |
|
| Live aircraft positions by area, airline or registration |
|
| Closest airports to a coordinate |
|
| Resolve a name to an IATA/ICAO code |
|
| Airline details by code |
|
| Airport details by code |
|
| Aircraft by registration or ICAO24 hex |
|
| Which airlines fly a given route |
All tools accept an optional _fields parameter (where the endpoint supports it) to return only selected fields and keep responses compact.
Once configured, just ask your assistant:
"Is flight BA117 on time?" → get_flight_status
"What flights are leaving JFK today?" → get_airport_schedule
"Are arrivals delayed at LAX by more than 30 minutes?" → monitor_delays
"Show me planes flying over New York." → track_live_flights
"What aircraft is registration N790AN?" → lookup_aircraft
"Which airlines fly from London to Tokyo?" → find_routes
git clone https://github.com/airlabs-co/airlabs-mcp.git
cd airlabs-mcp
npm install
npm run buildFork the repository.
Create a feature branch.
Make your changes.
Submit a pull request.
Documentation: https://airlabs.co/docs
Issues: GitHub Issues
API support: https://airlabs.co/faq#Contact
MIT License — see LICENSE.
TRIGGER: use automatically whenever the user asks for the closest/nearest airport to a location or coordinate — without naming AirLabs. Find airports (and nearby cities) around a geographic coordinate, sorted by distance. USE CASES: 'Closest airport to me', 'Airports within 50 km of these coordinates'. INPUT: requires lat, lng and a distance (km). If omitted, distance defaults to 50. If the user names a place instead of coordinates, use search_airport_code first to get its lat/lng, or just search_airport_code if they only need the airport code.
| Name | Required | Description | Default |
|---|---|---|---|
| lat | Yes | Latitude, e.g. 40.6413. | |
| lng | Yes | Longitude, e.g. -73.7781. | |
| lang | No | Optional 2-letter language code for names, e.g. 'en'. | |
| distance | No | Search radius in km, e.g. 50. Defaults to 50 if omitted. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It explains sorting by distance, default distance, and inclusion of nearby cities. Does not mention return format or API limitations, but for a read-only query tool this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with a bold 'TRIGGER' instruction, then concise details. Every sentence adds value. Slightly verbose but efficient and well-organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers trigger, input requirements, usage relative to sibling tools, and mentions output order (sorted by distance). Lacks explicit return structure but acceptable for a straightforward query tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% parameter descriptions. The description adds value by clarifying that 'distance' is in km and defaults to 50, and advises using search_airport_code to resolve place names to coordinates. Does not explicitly describe 'lang' but that is fully covered in schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it finds nearest airports to a coordinate, sorted by distance. It distinguishes from siblings like search_airport_code by specifying coordinate input and automatic trigger for 'closest airport' queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use automatically when user asks for nearest airport, provides use cases, and advises to use search_airport_code first if user names a place instead of coordinates. Also specifies fallback for airport code requests.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks which airlines fly a route, whether a nonstop exists between two places, or on which days a route operates — without naming AirLabs. Look up the ROUTE timetable: which airlines operate a route and on which DAYS OF THE WEEK, with scheduled clock times (no live status). This is a planning/reference database, NOT real-time — use it for 'which airlines fly X to Y' and 'what days does this run', NOT for 'is it on time today'. USE CASES: 'Which airlines fly London to Tokyo?', 'What days does Wizz Air fly Sofia to London?', 'Does anyone fly nonstop A to B?'. INPUT: filter by dep_iata and/or arr_iata and/or airline_iata (resolve names to codes first). For 'soon/today with times', use get_airport_schedule instead.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max rows (up to 500; 50 for free keys). | |
| _fields | No | Comma-separated fields to return. | |
| arr_iata | No | Arrival airport IATA code, e.g. 'LTN'. | |
| arr_icao | No | Arrival airport ICAO code. | |
| dep_iata | No | Departure airport IATA code, e.g. 'SOF'. | |
| dep_icao | No | Departure airport ICAO code. | |
| flight_iata | No | Filter by flight IATA number. | |
| airline_iata | No | Filter by airline IATA code, e.g. 'W6'. | |
| airline_icao | No | Filter by airline ICAO code. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses it is a planning/reference database with no live status, and lists what it returns (airlines, days, scheduled times). This is complete transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is thorough but not wasteful: a trigger statement, core functionality, use cases, and input tips. It is slightly long but well-structured and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 9 parameters, no annotations, and no output schema, the description covers purpose, usage guidelines, filtering hints, and exclusions completely. Missing output description is acceptable as no output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so baseline is 3. The description adds value by explaining the filtering fields (dep_iata, arr_iata, airline_iata) and instructs to resolve names to codes first, providing context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up route timetables: which airlines operate a route and on which days, with scheduled times. It distinguishes from real-time tools and provides specific use cases like 'Which airlines fly London to Tokyo?'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says when to use (user asks about airlines flying a route, nonstop existence, days of operation) and when NOT to use (not for real-time status, directs to get_airport_schedule for 'soon/today with times'). Also advises to resolve names to codes first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks about an airline (details, IATA/ICAO code, fleet size, country, safety), or names an airline that must be turned into a code for another query — without naming AirLabs. Look up airline(s) in the airlines database. Returns name, IATA & ICAO codes, callsign, country, fleet size, average fleet age, cargo/passenger/scheduled flags, safety stats and social links. USE CASES: 'Tell me about United', 'What's Wizz Air's IATA code?', 'How big is Ryanair's fleet?', 'List airlines in Bulgaria' (country_code='BG'). KEY WORKFLOW ROLE: this is how you turn an AIRLINE NAME into a CODE. Call get_airline_info(name='Wizz Air') to get iata_code 'W6', then use 'W6' in get_airport_schedule / find_routes / monitor_delays. (search_airport_code does NOT do airlines — only places.) INPUT: provide name (fuzzy), or iata_code/icao_code (exact), or country_code to list a country's carriers.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Airline name to search, e.g. 'Wizz Air', 'Ryanair'. | |
| _fields | No | Comma-separated fields, e.g. 'name,iata_code,icao_code,country_code'. | |
| callsign | No | Filter by ICAO callsign. | |
| iata_code | No | Airline IATA code, e.g. 'W6'. | |
| icao_code | No | Airline ICAO code, e.g. 'WZZ'. | |
| country_code | No | ISO-2 country code to list carriers, e.g. 'BG'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes parameter behavior (name fuzzy, iata_code/icao_code exact, country_code lists carriers). Mentions returned fields comprehensively. No annotations provided, so description carries full burden; could clarify fuzzy matching behavior for multiple matches, but overall transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While lengthy (multiple paragraphs), it is well-structured into clear sections (TRIGGER, USE CASES, KEY WORKFLOW ROLE, INPUT). Each sentence adds value. Front-loaded with trigger instruction. Could be slightly more concise but structure aids readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a lookup tool without output schema: explains what is returned (name, codes, callsign, country, fleet, safety stats, social links), parameter effects, and integration with workflow. Covers use cases and alternatives thoroughly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3). Description adds value beyond schema by explaining fuzzy vs exact matching, country_code listing carriers, and special parameter behaviors. Joins parameter semantics with workflow context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it looks up airline(s) in the airlines database, returning name, codes, and other details. It distinguishes from siblings like search_airport_code, which does not do airlines. Use cases are explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Includes a 'TRIGGER' section for automatic use, 'USE CASES' with examples, and a 'KEY WORKFLOW ROLE' explaining how to turn an airline name into a code for other queries. Explicitly mentions alternative tool (search_airport_code) and when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks about an airport's details (full name, city, country, timezone, coordinates, runways), or to expand an airport code into a full name — without naming AirLabs. Look up airport(s) in the airports database by code. Returns full name, city, country, coordinates, elevation, timezone, runways, yearly departures and localized names. USE CASES: 'What's the full name of LHR?', 'Where is SOF?', 'List all airports in Bulgaria' (country_code='BG'), 'airports in the PAR city group' (city_code='PAR'). WORKFLOW ROLE: after get_airport_schedule or find_routes returns destination codes (arr_iata), call this per code to give the user full airport NAMES instead of bare codes. INPUT: iata_code or icao_code (one airport), or country_code/city_code (a list).
| Name | Required | Description | Default |
|---|---|---|---|
| _fields | No | Comma-separated fields, e.g. 'name,iata_code,city,country_code'. | |
| city_code | No | IATA metropolitan city code, e.g. 'PAR', 'LON'. | |
| iata_code | No | Airport IATA code, e.g. 'LHR', 'SOF'. | |
| icao_code | No | Airport ICAO code, e.g. 'EGLL', 'LBSF'. | |
| country_code | No | ISO-2 country code to list a country's airports, e.g. 'BG'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully takes on the burden of transparency. It describes inputs (iata_code, icao_code, country_code, city_code), the output fields (full name, city, country, coordinates, elevation, timezone, runways, yearly departures, localized names), and a trigger for automatic use. However, it does not address potential limitations like the maximum number of airports returned for country/city queries or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: TRIGGER, main function, USE CASES, WORKFLOW ROLE, INPUT. It is front-loaded with the most important trigger information and every sentence adds value. No redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers triggers, use cases, workflow integration, input options, and output fields comprehensively. Absence of output schema is mitigated by listing output fields. Minor missing detail: whether country/city queries have a result limit, but overall very complete for a lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds contextual value by linking parameters to use cases (e.g., iata_code for a single airport, country_code for a list) and explaining the _fields parameter. This goes beyond the schema's individual parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up airport details by code and returns comprehensive information. The TRIGGER statement instructs automatic use when a user asks about an airport's details or expands a code, distinguishing it from siblings by specifying its role after other tools like get_airport_schedule.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit use cases are provided (e.g., 'What's the full name of LHR?', 'List all airports in Bulgaria') along with a workflow role that tells the agent to call this tool after get_airport_schedule or find_routes to convert codes to names. This gives clear direction on when and how to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks what flights leave/arrive at an airport, or about departures/arrivals 'today / now / soon / in the next hours', or which destinations an airline serves from an airport right now — even without naming AirLabs. Get the LIVE departures/arrivals board for an airport (real-time, up to ~10 hours ahead). Each row has dep_time/arr_time, dep_estimated/arr_estimated, status, terminal, gate, delay, airline and flight number. THIS is the tool for questions about WHEN flights leave/arrive 'today' / 'soon' / 'right now'. USE CASES: 'What flights leave JFK today?', 'Show Wizz Air departures from Sofia in the next hours', 'Arrivals at LHR now'. INPUT: query by dep_iata (departures) OR arr_iata (arrivals). You may ADD airline_iata to filter by carrier, and/or flight_iata to list every instance of a number. WORKFLOW for 'Which airports does fly to from soon?':
get_airline_info(name='') -> airline IATA code (e.g. Wizz Air -> W6)
search_airport_code(q='') -> airport IATA code (e.g. Sofia -> SOF)
get_airport_schedule(dep_iata='SOF', airline_iata='W6') -> live departures w/ times
(optional) get_airport_info(iata_code=) -> full destination names Do NOT use find_routes for 'soon/today' — that returns a weekly timetable without live times. Use this tool when the user cares about actual times. TIME WINDOW & STATUS: the board covers a window from the recent past to several hours ahead, so it mixes flights that have not left yet, are airborne, and have already departed/landed. Each row's 'status' tells which: scheduled = not departed yet, active = airborne, landed = arrived (and 'cancelled'). Interpret the user's intent and filter the rows accordingly when their wording is specific: for 'upcoming / still to depart / next few hours' keep status=scheduled with a future dep_estimated/dep_time; for 'already left / departed' keep active/landed. If the user is NOT specific, do NOT drop rows — show them and label each with its status and time. Never silently hide matching flights; if filtering leaves nothing, say so and report what the board does contain.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max rows (airport: up to 1000; airline: 200; free keys: 50). | |
| _fields | No | Comma-separated fields to keep responses small, e.g. 'flight_iata,arr_iata,dep_time,dep_estimated,status'. | |
| arr_iata | No | Arrival airport IATA code, e.g. 'LHR'. | |
| arr_icao | No | Arrival airport ICAO code, e.g. 'EGLL'. | |
| dep_iata | No | Departure airport IATA code, e.g. 'SOF' (Sofia), 'JFK'. | |
| dep_icao | No | Departure airport ICAO code, e.g. 'LBSF'. | |
| flight_iata | No | List every instance of this flight IATA number. | |
| flight_icao | No | List every instance of this flight ICAO number. | |
| airline_iata | No | Filter the board by airline IATA code, e.g. 'W6' (Wizz Air). | |
| airline_icao | No | Filter the board by airline ICAO code, e.g. 'WZZ'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description fully discloses behavioral traits: time window covers recent past to hours ahead, explains status meanings (scheduled, active, landed), and gives specific filtering guidance. Warns not to silently hide rows and how to handle ambiguous queries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is well-structured with sections (TRIGGER, USE CASES, INPUT, WORKFLOW, TIME WINDOW). Though lengthy, each section serves a purpose. Slightly verbose in places but overall efficient for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description adequately explains return fields and statuses. Covers time window, filtering, and edge cases. Complete for the tool's purpose and context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with descriptions for all 10 parameters. Description adds value by clarifying usage of dep_iata/arr_iata as main input, optional airline_iata and flight_iata, and explains limit max values per key type. This exceeds the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves live departures/arrivals board for an airport, specifying fields like dep_time, arr_time, status, etc. It distinguishes from siblings by explicitly noting that find_routes returns weekly timetable without live times.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger conditions (when user asks about flights 'today/now/soon'), use cases, and a workflow example. Clearly states when NOT to use this tool (do not use find_routes for soon/today) and gives alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use when the user asks about an aviation city code/grouping or to list cities of a country in an aviation context — not for general geography questions. Look up cities in the world cities database by code or country. Returns city name, code, country, coordinates, timezone and population/popularity. USE CASES: 'Details for the LON city group', 'List cities in Bulgaria' (country_code='BG'). For turning a city NAME into a code, prefer search_airport_code (it also returns the airports for that city).
| Name | Required | Description | Default |
|---|---|---|---|
| _fields | No | Comma-separated fields, e.g. 'name,city_code,country_code'. | |
| city_code | No | IATA city code, e.g. 'LON', 'PAR'. | |
| country_code | No | ISO-2 country code, e.g. 'BG'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description discloses return fields (name, code, country, coordinates, timezone, population/popularity), indicates read-only intent (no mutation mentioned), and provides use case examples. Could be improved by explicitly stating read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is front-loaded with trigger, then action, returns, use cases, and sibling differentiation. Every sentence adds value with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup tool with 3 optional parameters and no output schema, the description covers all essential context: when to use, what it returns, example inputs, and differentiation from related tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters have schema descriptions (100% coverage), but description adds value by specifying default return fields when `_fields` is omitted, giving example values for `city_code` ('LON') and `country_code` ('BG'), and clarifying the aviation context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool looks up cities by code or country in an aviation database, with verb 'look up', resource 'cities in the world cities database', and distinguishes from sibling 'search_airport_code' which converts city name to code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: aviation city code/grouping queries or listing cities of a country in aviation context; when not to use: general geography; provides alternative sibling tool for name-to-code conversion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use mainly as a helper to resolve a country NAME to its ISO-2 code for filtering airlines/airports — not for general country facts. Look up countries in the countries database. Returns ISO-2/ISO-3 codes, name, continent and currency. USE CASES: 'What's the country code for Bulgaria?' (-> BG), 'currency of Spain'. Useful to resolve a country NAME to its ISO-2 code before filtering airlines/airports by country_code.
| Name | Required | Description | Default |
|---|---|---|---|
| code | No | ISO-2 country code, e.g. 'BG', 'ES'. | |
| _fields | No | Comma-separated fields, e.g. 'name,code,continent'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It states the tool returns ISO-2/ISO-3 codes, name, continent, and currency, which is helpful. However, it does not clarify what happens when both parameters are omitted (e.g., returns all countries?), nor does it address edge cases or errors. The description also introduces ambiguity by saying 'resolve a country NAME' while the schema only has a 'code' parameter for ISO-2 codes, potentially misleading about input.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences plus a use case. It is front-loaded with a clear trigger statement. However, the slight contradiction between 'name' and 'code' introduces unnecessary noise. Overall, it is efficient but not perfectly clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 optional params, no output schema), the description covers the main purpose and return fields. However, it fails to address the input ambiguity (name vs. code) and does not specify behavior when both parameters are missing. While the return format is described, the lack of clarity on inputs reduces completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides 100% coverage for both parameters ('code' and '_fields'). The description adds confusion by stating the tool resolves a country NAME, but the 'code' parameter is an ISO-2 code, not a name. This mismatch misleads about valid inputs. The description reiterates return fields but does not clarify the ambiguity or add meaningful detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to resolve a country name to its ISO-2 code for filtering airlines/airports. It specifies the resource (countries database) and the verb (look up). It also distinguishes itself from sibling tools by emphasizing its role as a helper for filtering, not for general facts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs when to use the tool ('TRIGGER: use mainly as a helper to resolve a country NAME to its ISO-2 code for filtering airlines/airports') and when not to use it ('not for general country facts'). It provides concrete use cases, such as determining country codes for Bulgaria or Spain, and explains how it assists with filtering by country_code.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically (no need for the user to mention 'AirLabs') whenever they ask about the status, arrival/departure time, gate, terminal, or delay of a SPECIFIC flight number — e.g. 'is BA117 on time?', 'when does LH401 land?', 'my flight AA6'. Get the live status of ONE flight by its flight number. Returns scheduled/estimated/actual departure & arrival times, status (scheduled/en-route/landed), terminal, gate, baggage belt, delay minutes, codeshare info, and aircraft details. Returns only the single closest live/scheduled/landed instance of that number. USE CASES: 'Is BA117 on time?', 'What gate is LH401?', 'Will my flight be late?'. INPUT: requires flight_iata OR flight_icao. If the user gives an airline NAME plus a number (e.g. 'Wizz Air 4321'), first call get_airline_info(name) to get the IATA code (W6) and build the flight_iata ('W64321'). NOTE: for ALL daily instances of a recurring number, use get_airport_schedule with flight_iata instead — this tool returns only one.
| Name | Required | Description | Default |
|---|---|---|---|
| _fields | No | Comma-separated fields to return, to keep the response small, e.g. 'status,arr_estimated,arr_delayed,arr_terminal,arr_gate'. | |
| flight_iata | No | Flight IATA code-number, e.g. 'BA117', 'AA6'. | |
| flight_icao | No | Flight ICAO code-number, e.g. 'BAW117'. Alternative to flight_iata. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description reveals key behavior: returns only single closest live/scheduled/landed instance, non-destructive read operation. Could mention rate limits, but not required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Structured with TRIGGER, INPUT, NOTE blocks for readability. Slightly lengthy but each sentence adds unique value. Front-loaded with trigger conditions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters and no output schema, the description fully covers return fields, single-instance behavior, alternative tool reference, and a prerequisite step. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds value by explaining the alternative parameters (flight_iata vs flight_icao) with example formats, and the _fields parameter for response trimming.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get the live status of ONE flight by its flight number' and lists return fields, distinguishing it from siblings like get_airport_schedule which returns multiple instances.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly defines TRIGGER for automatic use, provides example use cases, and states when NOT to use this tool (use get_airport_schedule for daily instances). Also gives a prerequisite step for airline name conversion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks about a specific aircraft (by tail/registration number or hex), its type/age/model, or about an airline's fleet — without naming AirLabs. Look up aircraft in the fleets database. Returns type, model, manufacturer, age, build year, engines, wake category, owner airline, and latest known position (when queried by a specific aircraft). USE CASES: 'What aircraft is N790AN?' (reg_number), 'Look up hex AAB812', 'Show Wizz Air's fleet' (airline_iata='W6'), 'How old is this plane?'. INPUT: reg_number, hex, or msn for ONE aircraft; airline_iata/airline_icao to list a carrier's fleet (use limit to cap size). If given an airline NAME, resolve via get_airline_info first. Latest geo-position is only included when you query by a specific aircraft (reg_number, hex, or msn).
| Name | Required | Description | Default |
|---|---|---|---|
| hex | No | ICAO24 24-bit hex address, e.g. 'AAB812'. | |
| msn | No | Manufacturer serial number. | |
| flag | No | Filter by registration country ISO-2 code, e.g. 'US'. | |
| limit | No | Max rows (up to 500; 50 for free keys). | |
| _fields | No | Comma-separated fields, e.g. 'reg_number,model,manufacturer,age'. | |
| reg_number | No | Aircraft registration / tail number, e.g. 'N790AN'. | |
| airline_iata | No | List the fleet of an airline by IATA code, e.g. 'W6'. | |
| airline_icao | No | List the fleet of an airline by ICAO code. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral details: position data is only included when querying a specific aircraft, limit cap (500 max, 50 for free keys), and the range of return fields. However, since there are no annotations, it could mention that this is a read-only operation and any potential freshness of data. The lack of contradiction and the added context elevate it above average.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description starts with a clear trigger statement and is well-organized with use cases and input guidance. While it is somewhat verbose, every sentence serves a purpose. It could be tightened slightly, but the structure aids readability and comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters and no output schema, the description adequately covers how to use the tool for both specific aircraft and fleet queries, lists return fields, and addresses a common ambiguity (airline name vs. code). Without an output schema, it doesn't detail the exact response format, but the listed fields and behavioral notes make it functional for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the schema: it groups parameters (reg_number/hex/msn for specific aircraft vs. airline codes for fleet listing), clarifies the position inclusion condition, and advises on resolving airline names. This context is crucial for correct use and goes well beyond the baseline 3 given 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up aircraft in a fleets database and lists the specific fields returned (type, model, manufacturer, etc.). It distinguishes from sibling tools by specifying its domain (aircraft lookup vs. airports/routes/flights) and providing a trigger for automatic invocation when the user asks about a specific aircraft or airline fleet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use (user asks about aircraft or airline fleet) and when not to (resolving airline name via get_airline_info first). It provides concrete use cases with examples, and explains the different input modes (specific aircraft vs. fleet listing). This gives the agent clear decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks about delayed flights — 'are flights delayed at ?', 'show departures running late', 'is delayed now?' — without needing to mention AirLabs. List flights currently delayed beyond a threshold, optionally filtered by airport or airline. Returns each delayed flight with its delay in minutes and new estimated time. USE CASES: 'Are arrivals at LAX delayed right now?', 'Show departures delayed 60+ min at JFK', 'Is Ryanair running late today?'. INPUT: requires type ('departures' or 'arrivals'); 'delay' is the minimum minutes to include. Optionally filter by dep_iata/arr_iata and/or airline_iata. If the user gives an airline or airport NAME, resolve it first (get_airline_info / search_airport_code). STATUS NOTE: a delay is most certain once a flight has actually left, so many results are already airborne (status=active) rather than still waiting to depart (status=scheduled). This is correct data, not an error. If the user specifically wants only flights that have NOT departed yet, keep status=scheduled; if they want what is delayed in the air right now, keep active. If they are not specific, show all matches and label each with its status — do not silently hide delayed flights just because they are already airborne.
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | Check departure or arrival delays. | |
| delay | No | Minimum delay in minutes to include, e.g. 30, 60. | |
| _fields | No | Comma-separated fields to return. | |
| arr_iata | No | Filter by arrival airport IATA, e.g. 'LAX'. | |
| dep_iata | No | Filter by departure airport IATA, e.g. 'LAX'. | |
| airline_iata | No | Filter by airline IATA code, e.g. 'AA'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that delayed flights are often already airborne (active status) rather than scheduled, explains this is correct data, and gives guidance on how to handle user preference—demonstrating full transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but efficiently front-loaded with trigger instruction, followed by purpose, use cases, parameter guidance, and status note. Every sentence adds value; minor redundancy could be trimmed but overall well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters (1 required), no output schema, and complex behavioral nuances, the description covers all necessary aspects: trigger, use cases, parameter usage, name resolution, and data interpretation. It explains the return format (delay minutes, new estimated time).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions, so baseline is 3. The description adds value by providing example values for 'delay', clarifying the resolution of names for airline/airport parameters, and explaining the 'type' parameter scope. Enriches beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists flights delayed beyond a threshold with optional filters, and includes trigger instructions and use cases that differentiate it from siblings like get_airport_schedule or track_live_flights.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit trigger instruction: 'use automatically whenever the user asks about delayed flights' with specific query patterns. Also directs to resolve airport/airline names first using other tools, and advises on status filtering based on user intent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically (often as the FIRST step of a chain) whenever the user names a city/country/airport in words and a code is needed, or asks 'what's the code for ' or 'airports in ' — without naming AirLabs. Autocomplete/resolve a PLACE name (airport, city, or country) into its IATA/ICAO code. Returns matched airports, cities, countries, and the airports belonging to a matched city or country. USE CASES: 'What's the code for Sofia?' -> SOF; 'airports in Spain' -> uses airports_by_countries. Call this FIRST whenever the user gives a city/country NAME and you need a code for get_airport_schedule, find_routes, or find_nearest_airport. IMPORTANT: this does NOT resolve AIRLINE names. To turn an airline name (e.g. 'Wizz Air') into its code, use get_airline_info(name=...) instead.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Part of an airport/city/country name, 3-30 characters, e.g. 'Sofia', 'Spain', 'JFK'. | |
| lang | No | Optional 2-letter language code, e.g. 'en'. | |
| _fields | No | Comma-separated fields, e.g. 'name,iata_code,icao_code'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must bear the burden. It describes return types (matched airports, cities, countries, airports-by-city/country). It is a read-only search operation, clearly safe. No mention of rate limits or pagination, but acceptable for a simple lookup.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with trigger conditions and key information. It is somewhat lengthy but each sentence adds value (triggers, use cases, exclusions). Could be slightly more concise, but structure is logical.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the excellent schema and sibling list, the description covers purpose, usage context, limitations, and provides examples. No output schema, but return types are described. Completely adequate for correct selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (all 3 parameters documented). The description adds context for 'q' (part of name, length), but schema already describes it. No significant additional meaning beyond schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool resolves place names into IATA/ICAO codes, with examples. It distinctly separates from siblings by explicitly noting it does not resolve airline names, directing to get_airline_info instead.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit TRIGGER language: 'use automatically (often as the FIRST step)', specific use cases (e.g., 'What's the code for Sofia?'), and clear guidance on when not to use (airline names) with alternative tool named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TRIGGER: use automatically whenever the user asks where aircraft are flying right now, to see planes over an area/on a map, or the live position of a specific aircraft/airline — without naming AirLabs. Get LIVE aircraft positions (lat, lng, altitude, speed, heading, squawk) for aircraft in the air right now. This is positional/map data — NOT schedule times. USE CASES: 'Show planes over New York', 'Where is aircraft N790AN right now?', 'Plot all Lufthansa flights currently airborne'. INPUT: filter by bbox (a map area), or by airline_iata, reg_number, flight_iata, dep_iata/arr_iata, or hex. Without filters it returns a very large global list — always filter or pass a bbox. For 'when does it depart/arrive' use get_airport_schedule or get_flight_status instead.
| Name | Required | Description | Default |
|---|---|---|---|
| hex | No | Filter by ICAO24 hex address, e.g. 'AAB812'. | |
| bbox | No | Map bounding box as 'SW_lat,SW_lng,NE_lat,NE_lng' (south-west lat, south-west lng, north-east lat, north-east lng), e.g. '40.5,-74.5,41.0,-73.5'. | |
| zoom | No | Map zoom 0-11 to thin out results for rendering. | |
| _fields | No | Comma-separated fields, e.g. 'hex,flight_iata,lat,lng,alt'. | |
| arr_iata | No | Filter by arrival airport IATA code. | |
| dep_iata | No | Filter by departure airport IATA code. | |
| reg_number | No | Filter by aircraft registration, e.g. 'N790AN'. | |
| flight_iata | No | Filter by flight IATA number. | |
| flight_icao | No | Filter by flight ICAO number. | |
| airline_iata | No | Filter by airline IATA code. | |
| airline_icao | No | Filter by airline ICAO code. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses positional/map data nature, and that unfiltered returns very large global list. Missing data freshness, rate limits, or auth requirements, but core behavior is well-covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with trigger, description, use cases, and input guidance. Every sentence adds value, no wasted words. Appropriate length for a complex tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 11 parameters with full schema coverage and no output schema, description explains purpose, usage, and distinguishes from siblings. Could explicitly mention return field names, but the description already lists them in the first sentence.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, baseline 3. Description lists filter options but does not add meaning beyond schema descriptions. It reinforces the need for filtering but doesn't provide additional semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns live aircraft positions (lat, lng, altitude, speed, heading, squawk). Includes specific use cases and distinguishes from schedule tools like get_airport_schedule and get_flight_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use automatically ('whenever the user asks where aircraft are flying right now'), provides concrete use cases, and advises against using for schedules by naming alternatives. Also warns to always filter or pass a bbox.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0find_nearest_airportfind_routesget_airline_infoget_airport_infoget_airport_scheduleget_city_infoget_country_infoget_flight_statuslookup_aircraftmonitor_delayssearch_airport_codetrack_live_flightsScored across 12 tools
Each tool has a clearly distinct purpose: airport code search, live schedules, airline info, aircraft lookup, delay monitoring, route timetables, etc. Descriptions preemptively clarify overlaps (e.g., get_airport_schedule vs. find_routes vs. monitor_delays), ensuring agents can reliably select the correct tool.
Tool names mix patterns: get_ prefixed info tools (get_airline_info), find_ verbs (find_routes), lookup_, monitor_, search_, track_. While all are descriptive, the lack of a single consistent convention (e.g., verb_noun) adds slight ambiguity, especially between get_airport_schedule and get_flight_status.
With 12 tools, the set is well-scoped for an aviation data server. Each tool addresses a distinct core function (resolving codes, live flight data, aircraft details, delays, routes) without redundancy or bloat. The count feels appropriate for the domain's complexity.
The tool set covers a comprehensive range of aviation information needs: airport/airline details, code resolution, live schedules, route planning, delay monitoring, flight status, aircraft lookup, and live tracking. No obvious gaps exist—the surface enables agents to answer most common queries about flights, airports, airlines, and aircraft.
Read-only airport delay, weather, and 24h forecast tools for AI assistants. Airport-level only.
Give AI assistants access to real-time data. Search the web, compare flights, find hotels, and more.
Search award flights and cash fares, optimize points, and predict fares inside ChatGPT and Claude.
Live flight prices and working booking links for AI agents and travel apps.
