--- title: "Checkout a trip — returns a checkout URL the user opens to pay, plus the Shared Payment Token params an agent can use to pay programmatically" method: POST path: "/v1/checkout" tags: ["Pricing & booking"] --- # Checkout a trip — returns a checkout URL the user opens to pay, plus the Shared Payment Token params an agent can use to pay programmatically `POST /v1/checkout` ## Request - Base URL: `https://api.gojinko.com` - URL: `https://api.gojinko.com/v1/checkout` - Auth: one of: - API key in header `X-API-Key` - HTTP bearer Starts pricing when no valid quote exists and waits server-side for up to about 55 seconds. If the quote is still being priced, answers 503 QUOTE_PENDING with Retry-After; calling checkout again picks up the same quote. A successful response contains the quoted prices and checkout details; no GET trip polling is required first. A supplier offer rejected as expired or missing during pricing returns 410 OFFER_EXPIRED, even when no quote has ever succeeded. Search again and replace the item. QUOTE_EXPIRED instead describes an established quote that can no longer be used: its deadline passed, or the trip's travelers changed after it was priced (`reason: travelers_changed`). Call checkout again to re-quote. ## Request body - CheckoutRequest - `trip_id` string, required - `intent` IntentInput - `user_intent` string, nullable: The user's natural-language intent: the Alpic PII-stripped paraphrase when available, else a best-effort fallback to the client-provided NL query. ## Response `200` Checkout result: the priced trip and how to pay for it - CheckoutResponse - `quote_id` string, required: The quote this checkout priced. Pass it as `quote_id` to the typed agent payment, or to the MCP `submit_agent_payment`, to pay exactly this quote. - `quoted_cart_id` integer, required: Deprecated: use `quote_id` instead. The same quote as an integer. - `accepted_payment_types` object[], required - `type` 'spt', required - `requires` object, required - `headers` string[], required - `fields` string[], required - `authentication` 'customer_handoff' | 'unavailable', required - `session_id` string: The hosted payment page session behind `checkout_url`. Nothing on this API takes it; send the traveler to `checkout_url`. - `checkout_url` string - `status` string: Checkout state — "ready", "pending" or "failed". - `expires_at` string: When the quote behind this checkout stops being payable (RFC 3339). At most one hour from the call, and earlier when an offer in the trip carries a shorter deadline of its own (some airline fares last twenty minutes from their search) — pay before it passes. It is NOT a price hold: the supplier guarantees neither the price nor availability for the window, so an offer can lapse inside it. Nor is it the lifetime of `checkout_url`, which stays openable longer. After this instant the platform REFUSES to take payment rather than charging a stale price: `POST /v1/agent_payment/submit` answers **410 `QUOTE_EXPIRED`** and no payment object is created. To recover, call `POST /v1/checkout` again on the same trip — it re-quotes at the current price — and pay against the new `expires_at`. The hosted page cannot recover on its own: past this instant it shows the price as expired and the customer has to be sent a fresh checkout. The quote can also stop being payable before this instant if the trip's travelers change after pricing: payment is then refused with **410 `QUOTE_EXPIRED`** and `reason: travelers_changed`. - `payment_type` 'intent' | 'checkout' | 'agent': Which payment rail this trip is on. None of the values means payment has been collected: checkout only prices the trip, and you must still act to get it paid. `intent` — nothing has been charged or authorized yet; this is what a trip created through this API returns. Send the traveler to `checkout_url` to pay on the Jinko checkout page, or pay programmatically with POST /v1/agent_payment/submit using a type listed in `accepted_payment_types`. `checkout` — a payment page is already open for this trip; send the traveler to `checkout_url` to complete it. `agent` — a programmatic payment was already submitted for this quote through POST /v1/agent_payment/submit; check its outcome before submitting again. To choose how to pay, read `accepted_payment_types` and `agent_spt_params`, not this field. - `total_amount` object: Deprecated: use `total_amount_money` instead. The trip total in major currency units. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `total_amount_money` object: The trip total the checkout is priced at. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `items` TripItem[] - `item_id` string - `kind` string: What the item is: "flight", "hotel", "car" or "ground". - `offer_id` string: Deprecated: use `trip_item_token` instead. The offer handle this item was created from, exactly as it was submitted to `trip(add_item)`. On a hotel item it is the `htl_…` rate token; on a flight item it is the itinerary id. Two caveats when reconciling: on a hotel whose occupancy the provider re-shopped, this stays the token you SUBMITTED even though the priced rate moved; and a flight added twice on the same itinerary with different fares is de-duplicated by itinerary, so the echo can name the first fare added. - `trip_item_token` string: The handle `trip(add_item)` took, echoed verbatim. On a hotel or car item it is the offer’s `trip_item_token` from the search. On a flight item it is the itinerary id and the fare joined by a colon, absent when the fare half was never resolved (a caller-supplied snapshot skips the resolver); read that absence as "the platform cannot name the fare", never as a different fare. - `hotel_id` string: The property this hotel item books — the same id `hotel_search` publishes, so an item joins straight back to the search result it came from. Hotel items only. - `special_requests` string[]: The special requests submitted with `trip(add_item)` for this hotel item, as stored — trimmed, blank entries dropped — and forwarded to the hotel supplier at booking. Requests only — the hotel may not honour them, and a confirmed booking does not imply it will. Hotel items only; absent when none were given (JIN-2499). - `booking_scope` string: `room_bundle` means the submitted hotel offer token covers every room in `rooms`. Absent on every other hotel item, a single room included: read `rooms` for the rooms an item covers, and `booking_scope` only to learn whether one token books them all. - `num_rooms` integer: Number of rooms this hotel item covers: 1 for a single room, the bundle size for a room bundle. Hotel items only; absent when the platform cannot state the party the item was priced for. - `rooms` HotelBundleRoom[]: One entry per room this hotel item covers, single room or bundle (JIN-2565). Each entry states in `occupancy` the party that room was priced for — adults and children’s ages — so a checkout page can show the guest who the rate is for before payment, and a wrong child age, which changes the price and the room, is caught before the money moves. On a single room the entry’s room, board, refundability and tax lines are the item’s own, the same figures `hotel_terms` states; on a room bundle each entry carries that room’s details from the supplier. The item price remains the authoritative customer total for every room together. Absent when the platform holds no party for the item. - `occupancy_number` integer, required: Stable one-based room slot within this bundle. - `room_id` string - `mapped_room_id` integer - `room_name` string - `rate_id` string - `occupancy` Occupancy, required: The party one room is requested or priced for: the number of adults and the age of each child. - `adults` integer, required - `children_ages` integer[] - `board_type` string - `board_name` string - `max_occupancy` integer - `taxes_and_fees` TaxLine[] - `amount` number: Deprecated: use `amount_money` instead. The tax in MAJOR units of `currency`. - `currency` string: Deprecated: use `amount_money` instead. The currency of `amount`. - `amount_money` object: The tax. When the supplier named no currency for the line, it is the currency the rate is priced in. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `description` string: The provider’s own wording for the tax. Free text, not a code. - `included` boolean: True when the amount is ALREADY inside `total_amount_money`; false when the guest pays it at the property on top. Getting this backwards misquotes the trip. - `display` string: Deprecated: use `amount_money` instead. The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `policies` HotelBundleRoomPolicy[] - `type` string - `description` string - `fee_amount` number: Deprecated: use `fee_amount_money` instead. Customer policy fee in MAJOR units of `fee_currency`. - `fee_currency` string: Deprecated: use `fee_amount_money` instead. The currency of `fee_amount`. - `fee_amount_money` object: Customer cancellation or policy fee, with exact minor units and currency precision. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `is_refundable` boolean - `cancellation_policy` CancellationStep[] - `cancel_time` string: Deadline after which this tier applies. RFC 3339 with the supplier’s declared UTC offset. Steps whose deadline has no declared timezone are omitted from the ladder — the platform never invents an offset — so a schedule can be shorter than the supplier’s own. Tiers are chronological, earliest first, so the first entry is the deadline that matters. - `amount` number: Deprecated: use `amount_money` instead. Read `amount_money`, `percent` or `nights`, whichever this step carries. What the guest is charged on or after `cancel_time`: a sum in MAJOR units of `currency`, a percentage or a number of nights, as `type` says. - `currency` string: Deprecated: use `amount_money` instead. The currency of `amount`. - `type` string: How the charge is expressed — a sum ("amount", "flat_fee"; read `amount_money`), a percentage ("percent", "percentage"; read `percent`) or a number of nights ("nights"; read `nights`). - `display` string: Deprecated: use `amount_money` instead. The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `amount_money` object: What the guest is charged on or after `cancel_time`, when this step is a sum. Absent on a percentage or nights step, and when the supplier named no currency. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `percent` number: The charge as a percentage of the stay price, when this step is a percentage, on the 0–100 scale the supplier states it in: 50 is half the stay price, 100 the whole of it. Never a 0–1 fraction. Absent otherwise. - `nights` number: The charge as a number of nights of the stay, when this step is expressed in nights. Absent otherwise. - `free_cancellation_until` string - `payment_types` HotelPaymentType[]: How the rate can be settled. Each value appears at most once. - `remarks` string - `price` object: Deprecated: use `price_money` instead. Item total in major currency units. Absent until the trip has been quoted. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `price_money` object: Item total. Absent until the trip has been quoted — an unpriced item carries no `price_money` key at all, so absence means "not priced yet", not "free". - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `pax_count` number - `available_ancillaries` AncillaryOffer[]: Ancillaries that can still be selected on this item. Empty once nothing is on offer; populated only after the item has been quoted. - `offer_id` string, required: Opaque identifier of this ancillary offer. Pass it back exactly as received in `selections[].offer_id`; do not parse or build it. - `type` string: Ancillary family — "bag", "seat", "meal", "assistance", … An open set. Offers with type "seat" carry `seat_map` and no `price_per_unit`: the price is per seat, in `seat_map.seats[].price_money`. - `label` string: The provider label verbatim, kept as the source of truth. Some labels arrive with HTML entities and "&" component-joiners — show `display_label` instead. - `display_label` string: Human-readable rendering of `label`: HTML entities decoded, "&" joiners normalised to ", ". This is the one to display. - `description` string - `price_per_unit` object: Deprecated: use `price_per_unit_money` instead. The unit price in MAJOR currency units. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `price_per_unit_money` object: The price of one unit of this ancillary. Absent when the offer carries no price, and on seat offers, which price each seat in the seat map. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `scope` string: Seat offers only: one seat per passenger per segment. - `segment_ref_ids` string[]: The segment(s) a seat offer covers, one per offer. Pass the one entry back as the selection's `segment_ref_ids`. - `seat_map` AncillarySeatMap: The numbered seats for the segment covered by a seat offer. Select a seat with `available` true; its `price_money`, when present, is exact money in the trip currency. - `segment_ref_id` string - `flight_number` string - `seats` AncillarySeat[] - `seat_number` string - `available` boolean - `chargeable` boolean: True when the seat has a price. - `price` object: Deprecated: use `price_money` instead. The seat price in major units in the trip currency. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `price_money` object: The exact seat price in the trip currency. Absent for a free seat. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `characteristics` string[] - `seat_map_status` 'pending' | 'ready': Seat offers only: pending means the seat map is still loading and seat_map.seats is empty; read again. Ready means seats are listed. - `per_pax` boolean: True when the price is charged per passenger rather than once per booking. - `max_quantity` integer - `paid_at` 'now' | 'local': Car rate extras only. `now`: charged by Jinko at checkout and inside the item price once selected. `local`: collected by the rental desk on pick-up — selectable, but never part of the charge. Absent for flight ancillaries, which are always charged by Jinko. - `selected_ancillaries` SelectedAncillary[]: Ancillaries already selected on this item. - `offer_id` string, required: Opaque identifier of this ancillary offer. Pass it back exactly as received in `selections[].offer_id`; do not parse or build it. - `traveler_ref` string: The traveler the selection applies to; absent on a booking-level ancillary. - `pax_ref_id` string: Deprecated: use `traveler_ref` instead. Same value. - `quantity` integer - `type` string: Ancillary family on a booked outcome, e.g. "seat" or "bag" (lowercase, open set). May be absent before booking. - `seat_number` string - `segment_ref_ids` string[] - `price` object: Deprecated: use `price_money` instead. The unit price of the chosen seat, set by the server: major units in the trip currency. Absent for a free seat or a selection without its own unit price. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `price_money` object: The exact unit price of the chosen seat, set by the server. Absent for a free seat or a selection without its own unit price, e.g. a bag. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `status` 'pending' | 'confirmed' | 'failed': Absent before booking. For seats, `pending` means the airline has not confirmed the seat yet. `confirmed` means booked with the airline. `failed` means not booked. - `not_charged` boolean: true when this seat is not charged to the traveler. - `failure_reason` string: Why an ancillary failed, or why a pending airline outcome needs reconciliation. - `price_changed` boolean: True when the provider re-priced this item between the search snapshot and the live quote. Checkout PROCEEDS at the new `price` — show the change before taking payment. Read `price_change` for the two figures and the signed difference. Absent when the price held. - `original_price` object: Deprecated: use `original_price_money` instead. The snapshot price recorded at search time, in major currency units. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `original_price_money` object: The snapshot price recorded at search time. Present only when `price_changed` is true; compare it against `price_money` to show the caller what moved. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `price_change` PriceChange: The move between the price shown at search time and the price the trip is quoted at, stated as three figures so the caller can report it without subtracting. Read `original_money`, `current_money` and `delta_money`; the deprecated `original`, `current` and `delta` carry the same figures in major currency units. All are in one currency, matching the item’s price. Present ONLY when the two differ — an item whose price held carries no `price_change` at all, and `price_changed` is true whenever it is present. - `original` object, required: Deprecated: use `original_money` instead. The selling price shown at search time, before the quote, in MAJOR currency units. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `current` object, required: Deprecated: use `current_money` instead. The selling price the trip is quoted at — the same figure as `price` — in MAJOR currency units. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `delta` object, required: Deprecated: use `delta_money` instead. `current` minus `original`, SIGNED, in MAJOR currency units: positive when the price rose, negative when it fell. - `amount` number: Deprecated: use `value` instead (the same integer) where this object carries decimal_places. Where it does not, the figure is in MAJOR units and the field holding this object is itself deprecated: read its `*_money` sibling. The two-scale rule applies only to deprecated fields. Alternative to `value` on some endpoints (the two never appear together); its scale depends on decimal_places. When this object carries decimal_places, amount is an INTEGER in minor units — divide by 10 ** decimal_places (e.g. select_ancillaries total_with_ancillaries). When there is no decimal_places field, amount is a decimal in MAJOR units, safe to display as-is (e.g. trip and checkout totals). - `value` integer: Integer amount in MINOR units, always paired with decimal_places — divide by 10 ** decimal_places to display. Example: value 15977 with decimal_places 2 is 159.77 USD. Rendering this field directly shows prices 100x too high for 2-decimal currencies. - `currency` string: ISO 4217 currency code. - `decimal_places` integer: Scale of the integer value/amount: display = integer / 10 ** decimal_places. Always sent alongside minor-unit amounts. Usually the ISO 4217 digits of the currency (2 for USD/EUR/GBP, 0 for JPY/KRW, 3 for BHD/JOD/KWD) but currency-converted prices can carry a different scale — ALWAYS use the decimal_places sent with the amount, never a hardcoded 2. Only if the field is genuinely absent on a value-shaped object, fall back to the ISO digits for the currency. - `display` string: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `original_money` object: The selling price shown at search time, before the quote. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `current_money` object: The selling price the trip is quoted at — the same figure as `price_money`. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `delta_money` object: `current_money` minus `original_money`, SIGNED: `value` is positive when the price rose, negative when it fell. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `required_attributes` object: Extra attributes the carrier requires collected before booking this item — e.g. passport fields on carriers that mandate travel documents. Contents are passed through without additional validation. When this object is absent, no requirement is known; absence is NOT a statement that no document is needed. - `source` string: Origin of the requirement. Known values: "provider" (carrier-stated, authoritative) and "derived" (inferred from the itinerary; advisory only, not a compliance statement). The value is passed through without additional validation, so new sources may appear. - `per_passenger` string[]: Attribute names that must be collected for each passenger. Names are an open set in the provider’s own vocabulary. - `booking` string[]: Attribute names that must be collected once per booking. - `per_passenger_conditional` string[]: Attribute names that may be required for each passenger depending on carrier, route, or passenger details. Collect them when in doubt. - `booking_conditional` string[]: Attribute names that may be required once per booking depending on carrier, route, or passenger details. Collect them when in doubt. - `hotel_terms` HotelTerms: The rate terms behind a hotel item — cancellation ladder, taxes, board and room — as the platform holds them. They were captured at SEARCH time and are not re-confirmed at quote: read `terms_as_of` before treating any of them as a guarantee of what the provider will charge at booking. Present on hotel items only. - `terms_as_of` 'search' | 'quote': How fresh these terms are. `search` — captured in the search snapshot the item was created from and held since. `quote` — re-read from the provider when the trip was quoted. Today the platform always answers `search`. - `taxes_breakdown` TaxLine[]: Taxes and fees on the held rate. An empty array means no tax is known, not that there is none; check `included` per line before adding anything to the item price. - `amount` number: Deprecated: use `amount_money` instead. The tax in MAJOR units of `currency`. - `currency` string: Deprecated: use `amount_money` instead. The currency of `amount`. - `amount_money` object: The tax. When the supplier named no currency for the line, it is the currency the rate is priced in. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `description` string: The provider’s own wording for the tax. Free text, not a code. - `included` boolean: True when the amount is ALREADY inside `total_amount_money`; false when the guest pays it at the property on top. Getting this backwards misquotes the trip. - `display` string: Deprecated: use `amount_money` instead. The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `cancellation_schedule` CancellationStep[]: The penalty ladder for this rate, chronological. Absent when the provider published none — which is not a statement that cancelling is free. - `cancel_time` string: Deadline after which this tier applies. RFC 3339 with the supplier’s declared UTC offset. Steps whose deadline has no declared timezone are omitted from the ladder — the platform never invents an offset — so a schedule can be shorter than the supplier’s own. Tiers are chronological, earliest first, so the first entry is the deadline that matters. - `amount` number: Deprecated: use `amount_money` instead. Read `amount_money`, `percent` or `nights`, whichever this step carries. What the guest is charged on or after `cancel_time`: a sum in MAJOR units of `currency`, a percentage or a number of nights, as `type` says. - `currency` string: Deprecated: use `amount_money` instead. The currency of `amount`. - `type` string: How the charge is expressed — a sum ("amount", "flat_fee"; read `amount_money`), a percentage ("percent", "percentage"; read `percent`) or a number of nights ("nights"; read `nights`). - `display` string: Deprecated: use `amount_money` instead. The same figure as a string ready to show: the ISO 4217 code, a space, then the amount, e.g. "USD 159.77". With decimal_places it is written at exactly that scale (value 1561500, JPY, decimal_places 2 is "JPY 15615.00"); without, at the ISO digits of the currency. Show this; compute with the number. Absent when the figure is not money (a cancellation step expressed as a percent or a number of nights) or could not be read unambiguously. - `amount_money` object: What the guest is charged on or after `cancel_time`, when this step is a sum. Absent on a percentage or nights step, and when the supplier named no currency. - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `percent` number: The charge as a percentage of the stay price, when this step is a percentage, on the 0–100 scale the supplier states it in: 50 is half the stay price, 100 the whole of it. Never a 0–1 fraction. Absent otherwise. - `nights` number: The charge as a number of nights of the stay, when this step is expressed in nights. Absent otherwise. - `free_cancellation_until` string: Last instant the stay can be cancelled at no charge. RFC 3339 with the supplier’s declared UTC offset. Absent when the supplier declared no timezone — the platform never invents an offset, so a deadline it cannot place on the clock is withheld rather than published ambiguously — and absent when the rate is non-refundable or the provider named no deadline. - `is_refundable` boolean - `board_type` string - `board_name` string - `payment_types` HotelPaymentType[]: How the rate can be settled. Each value appears at most once. - `room_name` string - `room_capacity` integer - `agent_spt_params` AgentSPTParams: Parameters to scope a Shared Payment Token to, so an agent can pay programmatically instead of opening `checkout_url`: mint the token against these, then call POST /v1/agent_payment/submit with `trip_id` and the token. The currency is the trip currency: `USD` or `EUR`, depending on the partner's Stripe account binding. **Absent when the partner does not accept SPT for this trip currency**; use the returned `accepted_payment_types` to select an available payment method, or pay through `checkout_url`. The human checkout path ignores this object. - `max_amount` integer, required: Deprecated: use `max_amount_money` instead. Locked trip total in the smallest currency unit — scope the Shared Payment Token to at most this. - `currency` string, required: Deprecated: use `max_amount_money` instead. The trip currency: `USD` or `EUR`, depending on the partner's Stripe account binding. `agent_spt_params` is present only when the partner accepts SPT for this cart currency. - `max_amount_money` object: Locked trip total — scope the Shared Payment Token to at most `value` (minor units) in `currency`, the trip currency (`USD` or `EUR`, depending on the partner's Stripe account binding). - `value` integer, required: Integer amount in MINOR units at the ISO 4217 digits of `currency`: divide by 10 ** decimal_places to get the amount. Signed where the field says so (a price change delta). - `currency` string, required: ISO 4217 currency code. - `decimal_places` integer, required: The ISO 4217 digits of `currency` (2 for USD/EUR, 0 for JPY/KRW, 3 for BHD/KWD), and the scale of `value`. - `display` string, required: The same figure as a string ready to show: the ISO 4217 code, a space, then the amount at `decimal_places`, e.g. "USD 412.50". Show this; compute with `value`. - `stripe_profile` string: Stripe Agentic Commerce network_business_profile id the SPT is granted against. Empty until the preview account is provisioned. - `expires_at` string: When the quote these params are scoped to expires (RFC 3339) — the same instant as `expires_at` on the checkout response. Submitting a Shared Payment Token after it answers **410 `QUOTE_EXPIRED`** and redeems nothing; call `POST /v1/checkout` again and mint a fresh token against the new params. The quote can also be refused earlier if the trip's travelers change after pricing (`reason: travelers_changed`). ## Other responses - `400`: The request was refused. Invalid traveller names are refused with `BAD_REQUEST` and `error.field` naming the traveller. **`BAD_REQUEST`** — The request was malformed or failed validation. Fix the request as the message describes; retrying it unchanged cannot succeed. **`CURRENCY_UNSUPPORTED`** — The requested currency is not supported for this operation. Re-run the search in a supported currency. Agent payment supports `USD` or `EUR`, depending on the partner's Stripe account binding; a trip in a currency the partner does not accept carries no `agent_spt_params`. - `401`: Authentication required - `402`: Payment required — organization balance exhausted - `404`: Resource not found - `409`: The checkout could not proceed against the current state of the trip. Tell the causes apart by `error.code`. **`CONFLICT`** — The resource's current state refuses the operation. Re-read the resource and act on what it says — never retry blindly. **`TRIP_EXPIRED`** — The trip lapsed (24 hours without activity) and no longer accepts writes. Start a new trip and add the items again. A lapsed trip cannot be revived. **`TRIP_STATE_CONFLICT`** — The trip is in a state that refuses this operation: payment already started (`fulfilling`, `fulfilled`, `partially_fulfilled`), or it is `cancelled` or `failed`. Read `status` and act on it: read the trip to find the booking that already exists, or start a new trip. Nothing was written. **`OFFER_UNAVAILABLE`** — The provider can no longer quote this offer. Emitted today when the hotel supplier has no rate for your occupancy at quote time, and at checkout when a flight fare cannot be priced for the trip's travellers: the fare is not sold for them, or the airline declines to price it. Search again for the occupancy or the travellers you intend to book and pick an offer that covers them; this one cannot be quoted at any price. - `410`: The selected offer could not be priced, the established quote can no longer be used (`QUOTE_EXPIRED`, with `reason: travelers_changed` when the trip's travelers changed after it was priced), or another resource the request names is gone. Tell the causes apart by `error.code`. **`OFFER_EXPIRED`** — The search offer is no longer usable: its token expired, or the supplier rejected it as expired or missing during pricing. No payable quote was established. Search again, replace the unavailable item using the latest search result, and check out promptly. Show that the flight offer is no longer available; do not describe this as an established quote expiring (QUOTE_EXPIRED). **`GONE`** — The resource this request names existed and no longer does. Re-acquire it — search again, or check out again to re-quote — then retry with the new identifier. Repeating this request with the same one cannot succeed. **`QUOTE_EXPIRED`** — The quote can no longer be paid, so payment was refused before any payment object was created: either it passed its `expires_at`, or the trip's travelers changed after it was priced (`reason: travelers_changed`; `expires_at` is then the refusal instant). A typed payment refused this way also carries `payment_error` and `recovery`. Call `POST /v1/checkout` again on the same trip — it re-quotes — then mint a new Shared Payment Token against the new `agent_spt_params` and submit that against the new `quote_id`. Nothing was charged. - `422`: The trip is not complete enough to check out. Tell the causes apart by `error.code`. **`BAD_REQUEST`** — The request was malformed or failed validation. Fix the request as the message describes; retrying it unchanged cannot succeed. **`MISSING_CUSTOMER_DETAILS`** — The trip is missing details the booking needs: no travelers, a contact without both an email and a phone, or passenger documents a carrier requires (see `required_attributes` on the trip item). Send `upsert_travelers` with the travelers, a contact, and the fields named in `missing_fields`, then check out again. - `429`: Rate limit or quota exceeded - `502`: The travel provider rejected the request, or an upstream call failed - `503`: The quote is still being priced, or an upstream service is unavailable. **`QUOTE_PENDING`** — The trip's quote is still being priced. Call `POST /v1/checkout` again after the interval in `Retry-After`; the call picks up the same quote and answers with the checkout once it is priced. **`UPSTREAM_UNAVAILABLE`** — No provider can serve the request right now, for a reason that is not the request. Retry unchanged after the interval in `Retry-After`. - `504`: The upstream service did not answer before the deadline. **`UPSTREAM_TIMEOUT`** — A travel provider did not answer in time. Retry a read unchanged. Before repeating a request that changes something, read the resource's state because the operation may still have completed. --- [API](https://skmtc.dev/gojinko/apis/jinko-public-api.md) - [All operations](https://skmtc.dev/gojinko/apis/jinko-public-api/llms.txt) - [OpenAPI document](https://skmtc.dev/gojinko/apis/jinko-public-api/revisions/ac5046767e4c?raw)