AirHint APIdeals.airhint.com ↗
Search live flight itineraries and retrieve pre-computed monthly cheapest fares for any airport pair via the AirHint Deals API. Two endpoints, IATA codes.
What is the AirHint API?
The AirHint Deals API exposes 2 endpoints that cover live itinerary search and pre-computed monthly deal snapshots for any origin/destination airport pair. The search_flights endpoint returns price-sorted itineraries with airline names, stop counts, agent attribution, and booking links for a given departure date and optional return date. The list_cheapest_deals endpoint surfaces the site's cached cheapest-fare records for a calendar month without triggering a live search.
curl -X GET 'https://api.parse.bot/scraper/b7456778-be10-4197-a532-3f246fe7baee/search_flights?origin=FLR&destination=TLV&return_date=2026-11-24&departure_date=2026-11-21' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace deals-airhint-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: AirHint SDK — find cheap deals then search live fares."""
from parse_apis.deals_airhint_com_api import AirHint, TripType, InputNotFound
client = AirHint()
# Fetch the monthly cheapest-deal snapshot for Florence → Tel Aviv.
try:
listing = client.deal_listings.search(
origin="FLR", destination="TLV", month=11, trip_type=TripType.RETURN,
)
except InputNotFound:
print("No deals page for this route/month")
raise
print(listing.title, f"— {listing.total_deals} deals, {listing.updated}")
# Walk the pre-computed deals and find the cheapest one.
if listing.deals:
cheapest = None
for deal in listing.deals:
if deal.is_cheapest:
cheapest = deal
break
if cheapest is None:
cheapest = listing.deals[0]
print(f"Cheapest: {cheapest.airline_name} {cheapest.price_display} "
f"departs {cheapest.departure_date}, returns {cheapest.return_date}")
# Use the deal's dates to run a live fare search.
for itin in client.itineraries.search(
origin="FLR",
destination="TLV",
departure_date=cheapest.departure_date,
return_date=cheapest.return_date,
currency="USD",
limit=5,
):
airlines = ", ".join(itin.airline_names)
print(f" ${itin.total_price:.0f} via {airlines} — "
f"{itin.outbound_stops} stop(s) out, "
f"departs {itin.outbound_departure_time}")
# Show individual flight legs on the outbound.
for leg in itin.outbound_legs:
print(f" {leg.flight_number}: {leg.departure_time} → {leg.arrival_time}")
print("exercised: deal_listings.search / itineraries.search")
Runs a live fare search for one adult in economy between two airports on a departure date and, optionally, a return date (omit return_date for a one-way search). The site searches asynchronously, so one call takes roughly 5-20 seconds and may end with an upstream error asking to retry if results are not ready in time. Returns itineraries sorted by total price ascending (ties by outbound departure time); each itinerary carries the operating airline codes and names, the agent selling the fare, total price in the requested currency, outbound and return departure/arrival times in the local time of each airport (format YYYY-MM-DD HH:MM:SS, no timezone), stop counts and connection airports, per-leg flight numbers, a booking link on the site, and exact_dates_match, which is true when the first outbound leg departs on departure_date and (for round trips) the first return leg departs on return_date. alternative_dates is the site's list of suggested alternative dates and is empty on every search observed. Pagination is local over the full result set of one search: limit (default 20, max 100) and offset (default 0) select a window, total_results is the full count and has_more says whether a later window exists; every page re-runs the search upstream. A valid empty result (total_results 0, e.g. direct_only on a route with no non-stop service) is returned as success.
| Param | Type | Description |
|---|---|---|
| limit | integer | Number of itineraries in the returned window, clamped to 100. |
| offset | integer | Zero-based index of the first itinerary in the price-sorted result set. |
| originrequired | string | Departure airport IATA code, 3 letters (e.g. FLR). |
| currency | string | 3-letter ISO currency code for prices; USD and EUR were exercised, other codes are passed to the site unvalidated. |
| destinationrequired | string | Arrival airport IATA code, 3 letters (e.g. TLV). |
| direct_only | boolean | When true only non-stop itineraries are requested; routes without non-stop service return an empty result. |
| return_date | string | Return date, ISO YYYY-MM-DD, not before departure_date. Omitted = one-way search (return fields are null/empty). |
| departure_daterequired | string | Outbound date, ISO YYYY-MM-DD. |
{
"type": "object",
"fields": {
"limit": "window size applied",
"offset": "window start index applied",
"origin": "requested origin IATA code",
"currency": "currency of all prices",
"has_more": "true when itineraries exist beyond this window",
"destination": "requested destination IATA code",
"direct_only": "whether only non-stop itineraries were requested",
"itineraries": "array of itineraries sorted by total_price ascending; each has airline_codes, airline_names, agent, total_price (number), currency, cabin_class, outbound_departure_time/outbound_arrival_time (local), outbound_stops (count), outbound_stop_airports, outbound_legs (flight_number, airline_code, departure_time, arrival_time), return_* equivalents (null/empty for one-way), actual_departure_date, actual_return_date, exact_dates_match (boolean), alternative_dates (array, empty when none), booking_url",
"return_date": "requested return date, null for one-way",
"total_results": "number of itineraries the search produced (before windowing)",
"departure_date": "requested outbound date"
},
"sample": {
"data": {
"limit": 5,
"offset": 0,
"origin": "FLR",
"currency": "USD",
"has_more": true,
"destination": "TLV",
"direct_only": false,
"itineraries": [
{
"agent": "Skyscanner/Flightnetwork",
"currency": "USD",
"booking_url": "https://book.airhint.com/book/AZ/FLR/TLV/2026-11-19/2026-11-22/USD?price=332&channel=web&adults=1&children=0&infants=0&cabin_class=Y&affiliate=Skyscanner&data-affiliate=<redirect>",
"cabin_class": "Y",
"return_legs": [
{
"airline_code": "AZ",
"arrival_time": "2026-11-22 17:20:00",
"flight_number": "AZ807",
"departure_time": "2026-11-22 14:30:00"
},
{
"airline_code": "AZ",
"arrival_time": "2026-11-22 22:40:00",
"flight_number": "AZ1681",
"departure_time": "2026-11-22 21:45:00"
}
],
"total_price": 332,
"return_stops": 1,
"airline_codes": [
"AZ"
],
"airline_names": [
"ITA Airways"
],
"outbound_legs": [
{
"airline_code": "AZ",
"arrival_time": "2026-11-19 16:25:00",
"flight_number": "AZ1682",
"departure_time": "2026-11-19 15:30:00"
},
{
"airline_code": "AZ",
"arrival_time": "2026-11-20 03:10:00",
"flight_number": "AZ810",
"departure_time": "2026-11-19 22:50:00"
}
],
"outbound_stops": 1,
"alternative_dates": [],
"exact_dates_match": true,
"actual_return_date": "2026-11-22",
"return_arrival_time": "2026-11-22 22:40:00",
"return_stop_airports": [
"FCO"
],
"actual_departure_date": "2026-11-19",
"outbound_arrival_time": "2026-11-20 03:10:00",
"return_departure_time": "2026-11-22 14:30:00",
"outbound_stop_airports": [
"FCO"
],
"outbound_departure_time": "2026-11-19 15:30:00"
}
],
"return_date": "2026-11-22",
"total_results": 608,
"departure_date": "2026-11-19"
},
"status": "success"
}
}About the AirHint API
Live Itinerary Search
The search_flights endpoint accepts required origin, destination, and departure_date parameters (all IATA codes and ISO YYYY-MM-DD format). Passing a return_date shifts the search to a round-trip; omitting it returns one-way results with return fields set to null. Results are sorted by total_price ascending and paginated via limit (max 100) and offset. Each itinerary in the itineraries array includes airline_codes, airline_names, agent, total_price, and currency. The has_more flag tells you whether additional pages exist beyond the current window. Set direct_only to true to restrict results to non-stop service; routes without non-stop options return an empty array.
Monthly Cheapest Deals
The list_cheapest_deals endpoint takes an origin, destination, month (integer 1–12, resolved to the next occurrence), and optional trip_type (return or one-way). It returns a deals array where each record carries departure_date, return_date, airline_code, airline_name, and total_price. The updated field reflects the site's snapshot date, so you can tell how fresh the data is. The response also includes a title field (a human-readable route and month label) and a total_deals count. Prices observed in the wild default to USD.
Search Behavior and Pagination
Live searches run asynchronously and can take 5–20 seconds per call. The upstream search may occasionally surface an error asking for a retry; callers should handle non-200 or error-body responses with a backoff. The currency parameter on search_flights accepts any ISO 3-letter code, though only USD and EUR have been validated; other codes are passed through without client-side validation. The list_cheapest_deals endpoint does not support a currency override — prices appear in the site's default currency.
The AirHint API is a managed, monitored endpoint for deals.airhint.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when deals.airhint.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official deals.airhint.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Compare total round-trip prices across airlines for a fixed outbound and return date pair using
search_flights. - Build a fare calendar by calling
list_cheapest_dealsfor each month and mappingdeparture_datetototal_price. - Filter for non-stop fares only by setting
direct_only: trueinsearch_flightsand surfacingairline_namesto users. - Track the cheapest airline on a route each month using
airline_nameandtotal_pricefromlist_cheapest_deals. - Power a price-alert tool by polling
list_cheapest_dealsmonthly and diffingtotal_priceagainst a stored baseline. - Paginate through all available itineraries for a route using
offsetand thehas_moreflag to find sub-optimal but schedule-friendly options.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does AirHint have an official developer API?+
What does `search_flights` return beyond a price?+
airline_codes, airline_names, the agent through which the fare is offered, total_price, currency, stop information, and local departure and arrival times. The has_more field and total_results count support pagination across the full result set.How fresh is the data from `list_cheapest_deals`?+
updated field containing the site's snapshot date text. This is a pre-computed snapshot rather than a live search, so prices reflect the last time AirHint refreshed that route/month combination, not the current moment. For real-time prices, use search_flights instead.Can I search for multi-city or open-jaw itineraries?+
origin and destination IATA pair, with either a one-way or round-trip date structure. You can fork this API on Parse and revise it to add a multi-city or open-jaw endpoint if your itinerary data needs differ.Does the API cover cabin classes other than economy for one adult?+
search_flights runs searches for one adult in economy class; business, first, and premium economy fares and multi-passenger pricing are not exposed. You can fork this API on Parse and revise it to target a different cabin class or passenger count endpoint.