ignav.com

Ignav is a self-serve API that returns live flight fares and direct booking links as structured JSON. You send it a route and date, it returns itineraries with prices and an ignav_id, and you use that ID to fetch booking URLs from airlines and OTAs. It fits flight search apps, price trackers, and AI travel tools — and you can start with 1,000 free requests, no credit card required.

What the API actually returns

A fare search returns a JSON object with the route, date, and an itineraries array. Each itinerary contains:

• Price — amount, currency, and a status field (the example shows "verified")
• Outbound segments — carrier, flight number, operating carrier, departure/arrival airports, local and UTC times with timezones, duration, and aircraft
• Cabin class and a requires_self_transfer flag
• ignav_id — the key you pass to the booking-links endpoint

The ignav_id is the part that matters most: it's the bridge between "here's a price" and "here's where to buy it." Without it, you'd have a fare list but no way to convert it into a booking action.

How a request works

The documented example is a one-way search:

curl -X POST "https://ignav.com/api/fares/one-way" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"origin":"SFO","destination":"JFK","departure_date":"2026-11-03"}'

You supply an origin, destination, and departure date; you get back the itinerary structure above. The docs also describe round-trip search and a flexible search that supports one or two ordered legs and open-jaw trips — useful if your product needs multi-city or return itineraries rather than a single leg.

The workflow is two calls: search fares, then pass an ignav_id to request direct airline and OTA booking URLs. That's the "from question to booking link" pattern the site describes.

What it's built for

The site groups its intended use cases into three:

There's also an MCP server for AI agent integrations, which is relevant if you're wiring this into an LLM-based assistant rather than a traditional app.

Getting started

1. Get an API key — sign up for free; the first 1,000 requests don't require a credit card.
2. Search fares — start with one-way or round-trip; flexible search covers ordered legs and open-jaw.
3. Fetch booking links — pass an ignav_id to get airline and OTA booking URLs.

There's a Playground for testing requests without writing code, and client examples in cURL, Python, and JavaScript.

Billing and limits worth knowing

The site states that only successful requests are billed and that there is no rate limit. Pricing details live on the pricing page, so check there for current rates before you commit to a volume. The free tier is 1,000 requests with no credit card required — enough to validate the integration before spending anything.

When Ignav is a good fit

Choose it if you need live fares plus a bookable link in one flow, and you want to build on top of structured JSON rather than scrape or aggregate multiple sources yourself. It's a particularly natural fit for price-tracking products (the schedule-polling pattern is explicitly supported) and for AI agents that need to answer "what does this flight cost and where do I book it."

Look elsewhere if you need inventory beyond flights, or if your product requires booking and payment processing rather than handing the user off to an airline or OTA — Ignav returns links, not completed bookings.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

Ignav is a self-serve flight prices and booking links API. You can start without paying: sign up for a free API key, get 1,000 free requests, and no credit card is required. Only successful requests are billed, and there is no rate limit. If you want to test the workflow before writing code, the site offers a Playground alongside the docs.

What you get before paying anything

The free tier is enough to validate the core flow — search fares, then turn an itinerary into a booking link.

Pricing beyond the free requests is not specified in the available material, so treat the 1,000 requests as the trial scope and check the pricing page for current terms before scaling.

Getting started in three steps

1. Get an API key

Sign up for free. You start with 1,000 requests and no credit card is required. The API key is passed in the X-Api-Key header on each request.

2. Search fares

Start with one-way or round-trip. Flexible search also supports one or two ordered legs and open-jaw trips. A one-way request looks like this:

curl -X POST "https://ignav.com/api/fares/one-way" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"origin":"SFO","destination":"JFK","departure_date":"2026-11-03"}'

The response is structured JSON. Each itinerary includes price, outbound segment details (carrier, flight number, airports, local and UTC times, aircraft, duration), cabin class, whether a self-transfer is required, and an ignav_id.

3. Fetch booking links

Pass an ignav_id to request direct airline and OTA booking URLs. This is the step that turns a fare result into something a user can act on.

What the response actually contains

The example response for SFO → JFK shows the fields you can build on:

• price: amount, currency, and a status such as verified
• outbound: carrier, duration, and a segments array with flight numbers, operating carrier, departure/arrival airports, local and UTC times, timezones, and aircraft
• cabin_class and requires_self_transfer
• ignav_id: the handle used to fetch booking links

Because times are given in both local and UTC, you can display schedules without doing timezone math yourself.

What you can build with it

The site groups intended use into three patterns:

• Flight search apps — search fares, filter results, and fetch booking links for any route.
• Price trackers and alerts — poll routes on a schedule, compare fares over time, and notify users on drops.
• AI travel tools — look up airports, search live fares, and generate booking links from AI workflows. An MCP server is offered for agent integration.

Client options and common sticking points

cURL, Python, and JavaScript are supported, and the Playground lets you try requests without setting up a project. Practical things to plan for:

• The ignav_id is per itinerary, so store it if you want to fetch booking links later rather than re-searching.
• Check requires_self_transfer before presenting an itinerary as a single-ticket trip.
• Since billing counts only successful requests, failed calls during development should not consume your free allowance — but confirm this against the pricing page if your usage grows.

If your goal is to see whether the data fits your product, the fastest path is: get a key, run one one-way search in the Playground, then fetch a booking link from the returned ignav_id.

Ignav's flight API answers a route question in two steps: a fare search returns live itineraries, each carrying an ignav_id, and a second call passes that ID to get booking URLs for airlines and OTAs. You need an API key, and the flow works for one-way, round-trip, flexible, and open-jaw searches. The site advertises 1,000 free requests, no credit card required, and billing only on successful requests.

The two-call flow

The API is built so that a question ("what does SFO to JFK cost on this date?") becomes a clickable booking link without scraping or manual lookup.

1. Search fares — send origin, destination, and date. The response contains itineraries with price, carrier, segments, times, and an ignav_id per itinerary.
2. Fetch booking links — pass the ignav_id back to the API to request direct airline and OTA booking URLs.

Every itinerary includes an ignav_id specifically so you can use it to fetch booking links. That ID is the handoff between the two calls.

Step 1: Request fares

A one-way search is a POST to /api/fares/one-way with your key in the X-Api-Key header:

curl -X POST "https://ignav.com/api/fares/one-way" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"origin":"SFO","destination":"JFK","departure_date":"2026-11-03"}'

The response is structured JSON. A sample itinerary looks like this:

{
  "origin": "SFO",
  "destination": "JFK",
  "departure_date": "2026-11-03",
  "itineraries": [
    {
      "price": { "amount": 299, "currency": "USD", "status": "verified" },
      "outbound": {
        "carrier": "American Airlines",
        "duration_minutes": 330,
        "segments": [
          {
            "marketing_carrier_code": "AA",
            "flight_number": "100",
            "operating_carrier_name": "American Airlines",
            "departure_airport": "SFO",
            "departure_time_local": "2026-11-03T08:00:00",
            "departure_timezone": "America/Los_Angeles",
            "departure_time_utc": "2026-11-03T15:00:00Z",
            "arrival_airport": "JFK",
            "arrival_time_local": "2026-11-03T16:30:00",
            "arrival_timezone": "America/New_York",
            "arrival_time_utc": "2026-11-03T20:30:00Z",
            "duration_minutes": 330,
            "aircraft": "Boeing 777"
          }
        ]
      },
      "cabin_class": "economy",
      "requires_self_transfer": false,
      "ignav_id": "5e4fcd2f1dc340649eb19f6ee2afb57a"
    }
  ]
}

What to read from this:

• price.status — "verified" signals the fare was checked; treat unverified values with more caution in a price tracker.
• requires_self_transfer — false here means a single through-ticket; true would mean the traveler collects bags and re-checks, which matters for connection risk.
• ignav_id — the value you carry into step 2.
• Local and UTC times are both present, so you can display local departure/arrival without doing timezone math yourself.

Step 2: Fetch booking links

Pass the ignav_id to request direct airline and OTA booking URLs. The docs describe this as the second half of the same flow: search fares, then fetch booking links for any route. The result is a link straight to the airline (or an OTA), so the user can complete the purchase at the source rather than through a reseller layer.

Search types the flow supports

Open-jaw means you fly into one city and out of another — useful for multi-city trips where the return isn't from the arrival airport.

Where this fits

The same two-call pattern serves three common products:

• Flight search apps — search fares, filter results, and fetch booking links for any route.
• Price trackers and alerts — poll routes on a schedule, compare fares over time, and notify users when prices drop. The price.status field and the stable ignav_id are what make repeated polling comparable.
• AI travel tools — look up airports, search live fares, and generate booking links from AI workflows. An MCP server is available for agent integration.

Practical notes and gotchas

• Keep the ignav_id. It's the only thing linking a displayed fare to its booking link. If you cache itineraries, cache the ID with them.
• Billing is per successful request. The site states only successful requests are billed, with 1,000 free requests to start and no rate limit. Confirm current terms on the pricing page before scaling a polling job.
• Polling has a cost shape. A price tracker that checks many routes frequently multiplies requests; since billing follows successful requests, design your schedule around what you actually need to alert on.
• Self-transfer itineraries need a UI warning. When requires_self_transfer is true, the traveler is responsible for the connection — surface that clearly.
• Booking links go to the source. The link points to the airline or an OTA, so final price and availability are confirmed at checkout, not by the API response.

Start by signing up for a key, running one fare search in the Playground or via cURL, then passing the returned ignav_id to the booking-link endpoint. That single round trip is the whole mechanism.

Ignav returns a structured JSON object per fare search. The top level echoes your query (origin, destination, departure_date) and holds an itineraries array. Each itinerary carries a price object, an outbound (and, for round-trip, inbound) leg with carrier, duration, and segment-level detail, plus cabin_class, requires_self_transfer, and an ignav_id you pass to the booking-links endpoint. If your app needs price amount, currency, verification status, carrier, timing in both local and UTC, and a booking handle, the response covers all of it.

Top-level fields

The response mirrors the request so you can key results back to the search.

The price object

Each itinerary's price is not a bare number — it carries context you can act on:

• amount — numeric fare value (e.g. 299)
• currency — ISO currency code (e.g. USD)
• status — verification state; the documented example shows "verified"

The status field matters if you build price trackers or alerts: it lets you distinguish a confirmed fare from one that still needs checking before you notify a user.

The outbound leg

The leg object describes the journey, not just the endpoints.

Segment fields

Each segment is where the granular data lives:

• marketing_carrier_code — e.g. AA
• flight_number — e.g. 100
• operating_carrier_name — who actually flies it
• departure_airport / arrival_airport
• departure_time_local, departure_timezone, departure_time_utc
• arrival_time_local, arrival_timezone, arrival_time_utc
• duration_minutes
• aircraft — e.g. Boeing 777

Providing both local and UTC times (with an IANA timezone string) means you can render times in the user's zone without doing your own offset math, and still sort or compare itineraries on a single clock.

Itinerary-level flags and the booking handle

Three fields sit alongside price and outbound:

• cabin_class — e.g. economy
• requires_self_transfer — boolean; true when the itinerary involves a self-transfer, which you may want to filter or flag for users
• ignav_id — a unique identifier for the itinerary

ignav_id is the bridge to the second call in the flow: you pass it to request direct airline and OTA booking URLs. Without it you have prices but no way to complete the "question to booking link" path.

What this means for your app

• Price trackers / alerts — poll on a schedule, compare price.amount over time, and gate notifications on price.status.
• Flight search UIs — filter on duration_minutes, carrier, cabin_class, and requires_self_transfer; display segment-level stops from the segments array.
• AI travel tools — the structured fields (airport codes, ISO dates, UTC timestamps, ignav_id) are directly usable as tool inputs and outputs without parsing free text.

How to see the exact shape

The documented request is a POST to https://ignav.com/api/fares/one-way with an X-Api-Key header and a JSON body such as {"origin":"SFO","destination":"JFK","departure_date":"2026-11-03"}. The response example above is what that call returns. Round-trip and flexible searches (one or two ordered legs, open-jaw) use the same field structure, with the additional leg appearing as inbound. The site states 1,000 free requests with no credit card required, and only successful requests are billed — so you can inspect real responses before committing.