> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.kitionz.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.kitionz.com/_mcp/server.

# 1 · Origins

POST https://sandbox-api.kitionz.com/v1/flights/origins
Content-Type: application/json

**List origin airports.**

**What:** the origin airports you can fly *from*, canonicalised to IATA.

**When:** to build the “from” field of a search form, or a route picker.

**How:** `POST` with a JSON body `{ tripType? }`. No query params.

**Trip kind:** leave `tripType` out to list every kind — airports with one-way flights AND airports that only round-trip packages leave from (the same meaning as `/search` without `tripType`). Send `ONE_WAY` or `ROUND_TRIP` to list only that kind. Round trips are asked only of suppliers that sell round-trip packages. **Send the same `tripType` (or none) to discovery and to `/search`:** a picker that lists every kind but a search that asks for one kind offers dates the search then finds nothing on.

**After:** `POST /destinations` (body `{ origin }`) to get where you can fly to.

**Each airport** carries `inventoryCategories` — the inventory kinds YOU can book there (the kinds of your suppliers that list it): `["SERIES"]` = pre-purchase/special fares, `["ONLINE"]` = live online/GDS, `[]` = none/unknown. Render a badge, or show only series airports by keeping rows whose `inventoryCategories` include `SERIES`.

**`sources` is optional.** Omit it to use every supplier you have switched on. Send a subset to narrow the picker, and send the SAME list to `/search` so the routes and dates a user can pick match the suppliers that will be searched. Get the codes from `GET /v1/flights/suppliers`; a code your key is not switched on for returns 403.

**Scope:** this returns only YOUR bookable origins. For the full searchable airport master (reference data — every airport, with timezone/geo/ICAO) call `GET /v1/airports/*`.

**Supplier health:** `meta.suppliers[]` has one entry per supplier Kitionz considered, for each trip kind it was asked about: `{ sourceCode, tripType, status, tookMs }`. With no `tripType` in the request, a supplier that sells round trips has two entries (`ONE_WAY` and `ROUND_TRIP`). `status` = `ok`, `not_asked`, or a classified error code. `not_asked` (with `reason` = `ORIGIN_NOT_LISTED` or `DEST_NOT_LISTED`) means the supplier was not called because its own saved list for the previous step did not contain the airport — an answer, not a fault; treat only error codes as failures, and treat an unrecognised `status` as opaque. If a supplier fails (or is backing off after rate-limiting Kitionz) and Kitionz holds a recent good answer from it, that answer is still included and its entry carries `stale: true` + `staleAgeMs` (route lists up to 24 h old, date lists up to 2 h old with past dates removed). Route lists are cached for up to 2 h and date lists for up to 15 min: a list is served from the cache inside its window and fetched again on the first request after it.

**Example — request** (an empty body lists every trip kind):

```json
{}
```

**Response (trimmed)** — `data` is the airport array; `meta.count` is the total:

```json
{ "data": [ { "iataCode": "DEL", "name": "Indira Gandhi Intl", "city": "Delhi", "inventoryCategories": ["SERIES"] } ], "meta": { "count": 1 } }
```

Reference: https://docs.kitionz.com/flight-api/1-origins

## Authentication

- `Authorization` header (bearer token, required) — Your Kitionz API key, sent as `Authorization: Bearer keyId:secret`. Create it in your Kitionz console under **API → API keys**.

## Servers

- `https://sandbox-api.kitionz.com` (Test, default)
- `https://api.kitionz.com` (Live)

## Request

### Body (application/json)

This endpoint expects an originsBody.

- `tripType` (enum, optional) — ONE_WAY or ROUND_TRIP lists only that kind of trip. Leave it out to list every kind: one-way flights and round-trip packages together (as /search does).
  - Allowed values: `ONE_WAY`, `ROUND_TRIP`
- `sources` (list of string, optional) — Optional. Leave it out to use every supplier your account has switched on. Send a list of sourceCodes only to narrow this call to some of them; a code you cannot use is refused (403), and blank entries are ignored.

## Response

### 200

Default Response

- `success` (boolean, required)
- `statusCode` (double, required)
- `data` (list of FlightOrigin, required)
- `meta` (V1FlightsOriginsPostResponsesContentApplicationJsonSchemaMeta, required)

## Types

### FlightOrigin

A canonical (master-resolved) bookable origin airport.

- `iataCode` (string, required)
- `airportName` (string, required)
- `city` (string, required)
- `country` (string, required)
- `countryCode` (string, required)
- `metroCode` (string, required, nullable)
- `icaoCode` (string, required, nullable)
- `countryCode3` (string, required)
- `timezone` (string, required, nullable)
- `latitude` (double, required, nullable)
- `longitude` (double, required, nullable)
- `isInternational` (boolean, required)
- `inventoryCategories` (list of enum, required)
  - Allowed values: `SERIES`, `ONLINE`

### V1FlightsOriginsPostResponsesContentApplicationJsonSchemaMeta

- `requestId` (string, required)
- `timestamp` (datetime, required)
- `path` (string, required)
- `method` (string, required)
- `responseTime` (double, optional)
- `pagination` (V1FlightsOriginsPostResponsesContentApplicationJsonSchemaMetaPagination, optional)

### V1FlightsOriginsPostResponsesContentApplicationJsonSchemaMetaPagination

- `page` (double, optional)
- `limit` (double, optional)
- `total` (double, optional)
- `totalPages` (double, optional)
- `hasNext` (boolean, optional)
- `hasPrev` (boolean, optional)

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "success": true,
  "statusCode": 200,
  "data": [
    {
      "iataCode": "DEL",
      "airportName": "Indira Gandhi International Airport",
      "city": "New Delhi",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VIDP",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 28.5562,
      "longitude": 77.1,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "BOM",
      "airportName": "Chhatrapati Shivaji Maharaj International Airport",
      "city": "Mumbai",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VABB",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 19.0887,
      "longitude": 72.8679,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "BLR",
      "airportName": "Kempegowda International Airport",
      "city": "Bengaluru",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VOBL",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 13.1979,
      "longitude": 77.7063,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "MAA",
      "airportName": "Chennai International Airport",
      "city": "Chennai",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VOMM",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 12.9941,
      "longitude": 80.1709,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "CCU",
      "airportName": "Netaji Subhas Chandra Bose International Airport",
      "city": "Kolkata",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VECC",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 22.6547,
      "longitude": 88.4467,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "HYD",
      "airportName": "Rajiv Gandhi International Airport",
      "city": "Hyderabad",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VOHS",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 17.2313,
      "longitude": 78.4299,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "GOI",
      "airportName": "Goa International Airport",
      "city": "Vasco",
      "country": "India",
      "countryCode": "IN",
      "metroCode": null,
      "icaoCode": "VOGO",
      "countryCode3": "IND",
      "timezone": "Asia/Kolkata",
      "latitude": 15.3808,
      "longitude": 73.8314,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "DXB",
      "airportName": "Dubai International Airport",
      "city": "Dubai",
      "country": "United Arab Emirates",
      "countryCode": "AE",
      "metroCode": null,
      "icaoCode": "OMDB",
      "countryCode3": "ARE",
      "timezone": "Asia/Dubai",
      "latitude": 25.2528,
      "longitude": 55.3644,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    },
    {
      "iataCode": "SIN",
      "airportName": "Singapore Changi Airport",
      "city": "Singapore",
      "country": "Singapore",
      "countryCode": "SG",
      "metroCode": null,
      "icaoCode": "WSSS",
      "countryCode3": "SGP",
      "timezone": "Asia/Singapore",
      "latitude": 1.3502,
      "longitude": 103.994,
      "isInternational": true,
      "inventoryCategories": [
        "ONLINE"
      ]
    }
  ],
  "meta": {
    "requestId": "req_034n1fbHViEqT1ydcyaYy6",
    "timestamp": "2026-10-27T05:54:25.303Z",
    "path": "/v1/flights/origins",
    "method": "POST",
    "count": 9,
    "supplierDisclosure": "AFTER_BOOKING",
    "suppliers": []
  }
}
```

**SDK Code**

```python
import requests

url = "https://sandbox-api.kitionz.com/v1/flights/origins"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://sandbox-api.kitionz.com/v1/flights/origins';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://sandbox-api.kitionz.com/v1/flights/origins"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://sandbox-api.kitionz.com/v1/flights/origins")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://sandbox-api.kitionz.com/v1/flights/origins")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://sandbox-api.kitionz.com/v1/flights/origins', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://sandbox-api.kitionz.com/v1/flights/origins");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://sandbox-api.kitionz.com/v1/flights/origins")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```