Types
Below are all the available GraphQL types and fields. Please refer to the getting started guide for detailed information and examples on how to use the API.
Try it out
Explore the GraphQL Schema and start making requests with the interactive API console. Visit the console
Query
journeys
journeys(
origin: LocationInput!
destination: LocationInput!
date: Date!
filter: JourneyFilterInput
via: [ViaInput!]
passengers: [PassengerPlaceholderInput!]
currency: String
): [Journey!]!
Get all possible journeys between origin and destination on given date
Arguments
Origin location
Destination location
Date of departure
filterJourneyFilterInput
Optional filter for journey search
via[ViaInput!]
Optional via stopovers
passengers[PassengerPlaceholderInput!]
Passenger details required for availability
Currency to display availability prices in
journeyOffer
journeyOffer(
journeyId: ID!
passengers: [PassengerPlaceholderInput!]!
currency: String
): JourneyOffer!
This will check live availablity with the train operators and return the given journey with priced offers. Call this when the user has requested prices.
Arguments
Id of the Journey to get fares for
Passenger details
Currency to display prices in
combinedJourneyOffer
combinedJourneyOffer(
outboundJourneyId: ID!
inboundJourneyId: ID!
passengers: [PassengerPlaceholderInput!]!
currency: String
): CombinedJourneyOffer!
This will check live availablity for an outbound and an inbound journey priced together as a round trip. Where a provider sells true return fares they surface in the matched legs' offers; otherwise prices match two independent journeyOffer calls.
Arguments
Id of the outbound Journey to get fares for
Id of the inbound Journey to get fares for, from a search in the opposite direction
Passenger details, applying to both directions
Currency to display prices in
getJourneyForBlueprint
getJourneyForBlueprint(
blueprint: ID!
date: Date!
passengers: [PassengerPlaceholderInput!]
currency: String
): Journey
This will return a journey constructed from a predefined Blueprint.
Blueprints are created in the Agent Dashboard and can be either a short connection or a multi‑leg trip with overnight stopovers along the way.
Arguments
Blueprint id to get journey for
Date of departure
passengers[PassengerPlaceholderInput!]
Passenger details required for availability
Currency to display availability prices in
getPassBundles
getPassBundles(
passengers: [PassPassengerInput!]!
departureDate: Date
filter: PassBundleFilterInput
currency: String
): [PassBundle!]!
Get applicable pass bundles for the given passengers
Arguments
Passenger details
departureDateDate
Planned departure date
filterPassBundleFilterInput
Optional filter for pass bundles
Currency to display prices in
getPassBundlesForJourneyOffer
getPassBundlesForJourneyOffer(
journeyOffer: ID!
passengers: [PassPassengerInput!]
filter: PassBundleFilterInput
currency: String
): [PassBundle!]!
Get applicable pass bundles for given journey offer
Arguments
Id of journey offer to get pass bundles for
passengers[PassPassengerInput!]
Passenger details
filterPassBundleFilterInput
Optional filter for pass bundles
Currency to display prices in
getJourneyRatings
Get comparative rating for journeys
Arguments
List of journey ids
getTicketingFee
Get fee for issuing tickets
Arguments
orders
orders(
after: String
before: String
first: Int
last: Int
query: String
sort: SortDirection
): OrderConnection!
List orders
Arguments
locations
locations(
filter: LocationsFilter
after: String
before: String
first: Int
last: Int
): LocationConnection!
Every location we can search and book from, optionally narrowed and
ordered by filter.
Without filter.query and filter.near the order is ascending on an
internal sequence and carries no meaning beyond being stable: it is the
order to walk when retrieving all of them. A location that is listed for
the whole walk is neither skipped nor repeated, however many are added or
withdrawn while it runs. One that joins the list mid-walk is yielded only
if it sorts after the cursor reached — and a location that has existed for
years can join it, because a location is listed from the day we can sell a
journey from it, not from the day the row was created. Repeat the walk to
pick those up.
With filter.query the order is relevance, and with filter.near alone
it is distance. Those lists are ranked when a page is read, so a location
added or withdrawn between two pages can shift the ones after it by a
place; they are for finding a location, not for retrieving all of them.
Cursors are opaque, so do not parse or construct one, and a cursor only
continues the list it came from: present it with the same filter.
totalCount counts the locations the filter leaves. Pages hold 25
locations by default and 100 at most.
Arguments
filterLocationsFilter
Narrows the locations and, with a text or a point, orders them
afterString
Cursor to start listing from
beforeString
Cursor to end listing at
firstInt
Number of locations to return (head)
lastInt
Number of locations to return (tail)
node
Use this query to get anything that implements the Node interface. It's the recommended way to get entities based on their id.
Arguments
travelCardOptions
travelCardOptions: [TravelCardOption!]!
Get available travel card options.
Returns the list of supported travel cards that can be attached to passengers.
Use the returned code when constructing TravelCardInput and consult
inputFields to determine which additional data is needed.
getSalesAgent
getSalesAgent: SalesAgent
Get sales agent details
me
me: User
Get the authenticated end user.
Requires a user token (JWT) in the Authorization header. A request without
one has no end user and fails with the USER_TOKEN_MISSING error code. Note
that an api-key header takes precedence over Authorization, so send only
the user token when querying this field.
campaigns
campaigns: [Campaign!]!
The sales campaigns available to the authenticated caller, ordered by code.
Every code returned is one the caller may sell under, so a client can offer the list as-is. The baseline terms a sale falls back to when no campaign is given are not a campaign to select and are never listed. Campaigns are not named here — a code has no display copy — so pair the codes with your own labels.
A campaign runs for a period and drops out of the listing once it ends, so re-read this rather than caching codes indefinitely. A booking already taken under a campaign is unaffected by its ending and can still be completed.
Which campaigns are available depends on who the request is authenticated
as. An api-key header takes precedence over Authorization, so send only
the user token (JWT) to list what an end user may sell under.
placeMapForPart
Get a map of places for a given offer and part
Arguments
refundableItems
refundableItems(orderId: ID!): [RefundableItem!]!
Returns a list of refundable items that can be refunded
Arguments
Id of the order
refunds
List all executed refunds for an order
Arguments
Id of the order
Mutation
createBooking
createBooking(
offerIds: [ID!]
passBundle: ID
currency: String
partnerId: String
passengers: [PassengerPlaceholderInput!]
): Booking!
Given a journey offer id, this will create a booking with the given journey offer. A booking is a temporary entity that holds the selected offers and passenger details.
See: https://docs.allaboard.eu/tickets/book-tickets, https://docs.allaboard.eu/passes/booking
Arguments
offerIds[ID!]
Ids of offers to add to booking
passBundleID
Id of pass bundle to att to booking
Currency to display prices in
partnerIdString
Partner id for tracking
passengers[PassengerPlaceholderInput!]
Passenger details to add to booking
updateBooking
updateBooking(
id: ID!
passengers: [FullPassengerInput!]
selections: [BookingSelectionInput!]
): Booking!
Select offers and update passenger details
Given a booking id and an offer id, this will select the offer in the booking. This is useful when the user has selected an offer and wants to add it to the booking.
Given a booking id and an array of passenger details, this will update the passenger details in the booking. See booking.requirements for required passenger fields. At least one passenger must be marked as the contact person with `isContactPerson: true` and `email` and `tel` must be provided.
Arguments
Id of booking to update
passengers[FullPassengerInput!]
Passenger details to update
selections[BookingSelectionInput!]
Booking selections to update
updatePart
updatePart(
id: ID!
booking: ID!
include: Boolean
placeProperties: [PlacePropertyInput!]
addAncillaries: [AddAncillaryInput!]
removeAncillaries: [RemoveAncillaryInput!]
placeSelections: [PlaceSelectionInput!]
): Booking!
Update an offer part of a booking
Arguments
Id of part to update
Id of booking to update
includeBoolean
Toggle inclusion of an optional reservation part
placeProperties[PlacePropertyInput!]
Place properties to update
addAncillaries[AddAncillaryInput!]
Ancillaries to add
removeAncillaries[RemoveAncillaryInput!]
Ancillaries to remove
placeSelections[PlaceSelectionInput!]
Places to select
setTicketDelivery
Record how the tickets for one offer should be delivered.
Returns the updated offer. Nothing else about the booking changes — no price, no selection, no other field — so there is nothing to refetch beyond the one case below.
One call covers the whole offer: every cost center of a multi-cost-center
booking, and both halves of a return whose inward direction is priced into
the outward fare. That inward half is a separate Offer with its own id, and
it is the only offer other than the returned one that a call can change, so
refetch it through the booking if you are displaying it. Its selectedOption
takes the same method when that method is among its own availableOptions,
and is cleared to null when it is not — a linked half is never left holding a
delivery its own options do not list.
Two separately selected single offers are set separately, even when the operator goes on to deliver them together — in that case it settles one delivery for both at purchase.
Arguments
Id of the offer to set the delivery method for
The method of one of the offer's ticketDelivery.availableOptions
createPayment
Initialise payment for an order through All Aboard.
The recommended flow is to first create an order with `createOrder` and then pass its `id` here as `orderId`. Once the payment has been succesfully processed, the user will be redirected to the successUrl with the `{order}` placeholder replaced by the order id. If the payment is cancelled, the user will be redirected to the cancelUrl.
For backwards compatibility a `booking` may be passed instead of `orderId`, in which case an order is created automatically before payment is initialised.
Arguments
orderIdID
Id of the order to pay for (from createOrder)
URL to redirect to in the case of payment cancellation
URI Template (RFC 6570) compliant string with {order} placeholder
Optional 2-letter language tag used to localise the payment page URL
createOrder
This will create an order from a booking. An order is a temporary entity that holds the selected offers and passenger details and prebooks the tickets.
It is normally after creating an order that you would collect payment.
Arguments
Id of booking to confirm
metadataJSONObject
JSON encoded string of metadata to attach to order
finalizeOrder
This will finalize an order and start issuing tickets.
Arguments
Id of order to finalize
refundItems
Execute refunds for selected refundable items
Arguments
createAccessToken
createAccessToken(
restrictions: AccessTokenRestrictionsInput!
capabilities: [AccessTokenCapability!]
ttlSeconds: Int
): AccessToken!
Mint an access token for one order.
Returns the token with its secret on token, the only time that value is
ever readable. Present it in the api-key header to read that order, and —
with WRITE — to refund it and to pay for it by card.
Minting is refused with NOT_AUTHORIZED unless the caller could itself do
everything the token is asked for: reading the order for READ, and
refunding it and paying for it by card for WRITE. A request authenticated
by an access token cannot mint another one, so a token's lifetime cannot be
extended by minting from behind it.
An order that does not exist, and one the caller may not read, both fail
with NOT_FOUND. Empty restrictions fails with INVALID_RESTRICTIONS,
and a ttlSeconds outside 1..86400 with INVALID_TTL.
Arguments
What the token is narrowed to. Must name an order.
What the token may do. Omit it for [READ]; [WRITE] implies READ.
An explicitly empty list fails with INVALID_CAPABILITIES.
How long the token lives, in seconds. 1..86400, default 900.
revokeAccessToken
revokeAccessToken(id: ID!): AccessToken!
Revoke an access token, so it stops authenticating anything immediately.
Idempotent: revoking an already-revoked token succeeds and leaves the
original revokedAt alone, so the trail keeps saying when the credential
actually stopped working.
Allowed for the agency that minted the token, or any agency above it in the
agent tree; anything else fails with NOT_AUTHORIZED. An id that names no
token fails with NOT_FOUND. The returned token carries token: null —
the secret is unreadable here as everywhere else.
Arguments
The AccessToken.id to revoke.
Subscription
journeys
journeys(
origin: LocationInput!
destination: LocationInput!
date: Date!
filter: JourneyFilterInput
via: [ViaInput!]
passengers: [PassengerPlaceholderInput!]
currency: String
): [Journey!]!
Get all possible journeys between origin and destination on given date
Journeys will be streamed as the routing algorithm resolves the best routes.
Arguments
Origin location
Destination location
Date of departure
filterJourneyFilterInput
Optional filter for journey search
via[ViaInput!]
Optional via stopovers
passengers[PassengerPlaceholderInput!]
Passenger details required for availability
Currency to display availability prices in
journeyOffer
journeyOffer(
journeyId: ID!
passengers: [PassengerPlaceholderInput!]!
currency: String
): JourneyOffer!
This will check live availablity with the train operators and return the given journey with priced offers. Call this when the user has requested prices.
The response is streamed, meaning that as operators return offers for parts of the journey, the result will update with more data for every payload.
Arguments
Id of the Journey to get fares for
Passenger details
Currency to display prices in
combinedJourneyOffer
combinedJourneyOffer(
outboundJourneyId: ID!
inboundJourneyId: ID!
passengers: [PassengerPlaceholderInput!]!
currency: String
): CombinedJourneyOffer!
This will check live availablity for an outbound and an inbound journey priced together as a round trip. Where a provider sells true return fares they surface in the matched legs' offers; otherwise prices match two independent journeyOffer calls.
The response is streamed, updating as each direction's legs resolve.
Arguments
Id of the outbound Journey to get fares for
Id of the inbound Journey to get fares for, from a search in the opposite direction
Passenger details, applying to both directions
Currency to display prices in
getJourneyForBlueprint
getJourneyForBlueprint(
blueprint: ID!
date: Date!
passengers: [PassengerPlaceholderInput!]
currency: String
): Journey
This will return a journey constructed from a predefined Blueprint.
Blueprints are created in the Agent Dashboard and can be either a short connection or a multi‑leg trip with overnight stopovers along the way.
The journey is streamed as the blueprint is being resolved into a journey.
Arguments
Blueprint id to get journey for
Date of departure
passengers[PassengerPlaceholderInput!]
Passenger details required for availability
Currency to display availability prices in
Objects
AccessToken Object
A credential that reaches one order and nothing else.
Presented in the api-key header, or as Authorization: Bearer, in place of
the agency's own API key — which is what makes it safe to put on a page the
public can open. Every request it authenticates is attributed to the agent
and user that minted it.
Fields
idID!
The token's own id, for revokeAccessToken and node. Not the secret.
tokenString
The secret to present as the api-key header.
Non-null exactly once, on what createAccessToken returns. It is stored
only as a hash, so nothing can hand it back afterwards: refetching the same
token through node returns it as null. Lose it and mint another.
capabilities[AccessTokenCapability!]!
What the token may do on its order, always at least READ.
restrictionsAccessTokenRestrictions!
What the token is narrowed to.
expiresAtZonedDateTime!
When the token stops working. Always in the future at minting.
revokedAtZonedDateTime
When the token was revoked, or null if it was not.
Null does not mean the token still works — an unrevoked token past
expiresAt is refused just the same.
AccessTokenRestrictions Object
What an access token is narrowed to. See AccessTokenRestrictionsInput.
Fields
orderIdID!
The order the token reaches, as its order_… id.
Accommodation Object
Accommodation details for a journey segment.
Describes the type of seating or sleeping arrangement available on a train/bus/ferry, including comfort level and specific features. Used to help passengers choose their preferred travel experience.
The description field provides human-readable details about the accommodation (e.g. "1 person sleeper cabin"), while subType contains a standardized code representation of the same information (e.g., "SINGLE").
Fields
AdmissionPart Object
The admission (tariff) part of an offer.
Represents the right to travel for the covered segments (the fare/tariff).
Contains the conditions the operator stated for the ticket and the
flexibility level, as well as the normalized serviceClass and
(operator-specific) comfortClass.
Fields
conditions[Condition!]!
Everything the provider stated about this part: refund and exchange rules
(ReturnCondition), the dates the ticket may be used on (ValidityCondition)
and other rules of use (TravelCondition), in that order. Render every
entry's description; see Condition for how to treat the kinds.
flexibilityFlexibility!
serviceClassServiceClass!
comfortClassString
segments[Segment!]!
priceMoney
Ancillary Object
An ancillary service that can be selected for a reservation.
Additional services or add-ons that passengers can purchase beyond the basic fare. These enhance the travel experience and may include meals, insurance, or special assistance.
Common types and examples:
- "BREAKFAST": On-board breakfast, pre-ordered meals
- "MEAL": On-board dining, pre-ordered meals
- "INSURANCE": Travel insurance, cancellation protection
- "LUGGAGE": Extra baggage allowance, bike transport
- "UPGRADE": Seat upgrades, priority boarding
- "ENTERTAINMENT": WiFi access, entertainment packages
The price field indicates the additional cost, while selections track which passengers have chosen this service.
Fields
idID!
nameString!
typeString!
descriptionString
imageFileResource
priceMoney
selections[AncillarySelection!]!
AncillarySelection Object
A selection of an ancillary service
Fields
AnonymousLocation Object
A station where stops may be made but journeys cannot be planned from/to
Fields
nameString!
Availability Object
Ticket availablility
Fields
statusAvailabilityStatus!
priceCategoryPriceCategory
accommodations[Accommodation!]
ticketClasses[TicketClass!]
BedAssignment Object
A bed assignment for a passenger
Fields
BlueprintJourney Object
A journey constructed from a predefined itinerary blueprint.
Uses a curated sequence of segments and optional stopovers defined by a blueprint. Blueprints are suitable for editorial or productized routes (e.g. scenic itineraries, recommended routes, or multi-city trips) and can include planned overnight stopovers.
Typical use cases:
- Publishing recommended routes with fixed or suggested stopovers
- Recreating saved or shared itineraries
- Ensuring specific paths or operators are used
Fields
BookedAdmissionPart Object
A the part of a booked offer that is the admission
Fields
BookedReservationPart Object
A part of a booked offer that is the reservation
Fields
Booking Object
Represents a temporary booking that holds selected offers, pass bundles, and passenger information before payment and confirmation. Bookings have a limited lifespan and must be confirmed before expiration.
If expiresAt is reached without confirmation, or if the booking fails for any
reason, the booking is automatically cancelled and offers are released back to
inventory. An expired or failed booking cannot be used again and will need to be
recreated from scratch.
Fields
idID!
expiresAtDateTime
ticketingFeeMoney
totalPriceMoney
passengers[Passenger!]
selections[BookingSelection!]
requirementsPassengerRequirements
termsAndConditions[String!]
BookingFare Object
A bookable fare offer for a journey
Fields
idID!
nameString!
priceMoney!
descriptionString
refundPolicies[String!]
placePreferences[PlacePreference!]
compartmentTypes[CompartmentType!]
Campaign Object
A sales campaign: an alternative set of terms and products to sell under.
Only campaigns the authenticated caller may use are returned, so any code listed here can be passed wherever a campaign code is accepted.
Fields
codeString!
The campaign's code, passed as campaignCode in the pass bundle filter to
see what the campaign offers.
products[Product!]!
Products this campaign currently covers, ordered alphabetically by key.
Every product listed has at least one pass on sale under this campaign, and a product not listed has none, so a client can offer the list as-is. Empty when the campaign's terms currently match nothing on sale.
Coverage is per campaign, not per party: a listed product can still yield no bundle for a particular set of travellers if it has no pass for one of their passenger types.
CardFieldRequirement Object
Describes whether a specific field is required for a travel card type.
Each entry maps a field name (e.g. "identifier") to a requirement level indicating if and when it must be provided.
Fields
fieldNameString!
Name of the field (e.g. "identifier")
requirementFieldRequirement!
Whether the field is required
CheckInResource Object
Resource that can be accessed for check-in and ticket issuing
Fields
urlString!
CombinedJourneyOffer Object
An outbound and an inbound journey priced together as a round trip, so providers that sell true return fares can return them. Offers hang off each direction's SegmentCollections, exactly as on a single JourneyOffer.
Fields
outboundJourneyOffer!
The outbound journey (origin → destination) with priced offers, possibly multi-leg
inboundJourneyOffer!
The inbound journey (destination → origin) with priced offers, possibly multi-leg
CompartmentType Object
A compartment type for a fare, e.g. Sleeper or Couchette
Fields
CostCenter Object
A cost center belonging to a sales agent, used for billing and payment routing
Fields
FileResource Object
Generic file resource that can be accessed or downloaded.
Represents digital assets associated with orders, such as tickets, boarding passes, receipts, and other travel documents. Resources are typically accessed via URLs and may have different formats.
Common resource types:
- application/pdf: PDF tickets, receipts, and documentation
- image/png: QR codes, boarding passes, and visual elements
- text/plain: Plain text instructions and confirmations
- application/json: Structured data and API responses
Resources may have access restrictions or expiration times depending on the type and operator policies.
Fields
FullPassenger Object
All passenger details
Fields
GenericOrderItem Object
An unspecified item in an order
Fields
GeoJsonPoint Object
Coordinates of a given location in GeoJSON Point format.
Follows the GeoJSON specification (RFC 7946) using WGS84 coordinate system. Coordinates are stored as [longitude, latitude] array (note the order).
Examples:
- London: [-0.1278, 51.5074] (longitude, latitude)
- Rome: [12.4964, 41.9028] (longitude, latitude)
- Stockholm: [18.0686, 59.3293] (longitude, latitude)
- Berlin: [13.4050, 52.5200] (longitude, latitude)
Note: The type field is always "Point" for this implementation.
Fields
JourneyFare Object
A fare offer for a journey
Fields
JourneyOffer Object
The composite offer for a journey: the journey itself (with itinerary)
carrying the bookable Offers that go together, grouped per
SegmentCollection. Compose a booking from whichever offer ids you choose
(createBooking). Produced by journeyOffer (single) and
combinedJourneyOffer (round trip).
Fields
JourneyOfferSelection Object
Selected journey offer that is part of a booking
Fields
journeyJourneySelection!
offers[Offer!]!
JourneyOrderItem Object
A booked journey from a journey offer, containing segments, tickets and other resources
Fields
JourneySelection Object
The journey selected for an offer
Fields
itinerary[ItineraryItem!]!
Location Object
Known location from and to which journeys can be planned
Fields
uidID!
nameString!
countryCodeString!
coordinatesGeoJsonPoint!
isMetaBoolean!
True when this location stands for a place rather than one station — "Paris" rather than one of its termini. A journey searched from it departs whichever station the route it is sold on uses, so read the departure off the journey's segments rather than assuming it.
LocationConnection Object
Paginated locations list result
Fields
edges[LocationEdge!]!
pageInfoPageInfo!
totalCountInt!
How many locations the whole list holds under the filter this page was
read with, or every location when there is none, counted when this page
was read. Locations are added and withdrawn, so paging through several
pages can end on a different number.
LocationEdge Object
A location edge in a paginated list
Fields
Money Object
Monetary sum using CLDR (Common Locale Data Repository) format.
The amount field represents the monetary value in the smallest currency unit:
- For currencies with decimal places (USD, EUR, GBP, etc.): amount is in cents (e.g., 1000 = $10.00, 1250 = €12.50)
- For currencies without decimal places (JPY, KRW, etc.): amount is in whole units (e.g., 1000 = ¥1000, 1250 = ¥1250)
Users are advised to consult the CLDR specification for proper currency formatting and display. The currency field contains the ISO 4217 currency code (e.g., "USD", "EUR", "JPY").
Examples:
- USD 1000 = $10.00 (1000 cents)
- EUR 1250 = €12.50 (1250 euro cents)
- JPY 1000 = ¥1000 (1000 yen, no decimal places)
- KRW 5000 = ₩5000 (5000 won, no decimal places)
Fields
NoChargeRedirect Object
Payment type used when no payment is required.
This payment type is used in cases where the order has a total price of 0.
The URL field will redirect to the provided successUrl.
Fields
NonStopJourney Object
A direct journey with no planned stopovers.
Represents the optimal (fastest) end-to-end route from origin to destination without overnight stopovers. Transfers between trains may still occur, but the itinerary does not intentionally include long breaks or multi-day segments.
While this optimizes for speed, it may result in less comfortable connections that require transfers at inconvenient times.
Use when passengers want the fastest connection in a single travel day where possible.
Fields
Offer Object
A priced, bookable combination of entitlements for a journey.
An offer bundles everything needed to travel on a ticketable segment of an itinerary. It is made up of one or more parts:
AdmissionPart: the right-to-travel/tariff entitlement (admission to board)ReservationPart: optional seat/berth reservations and add-ons
Pricing and composition:
price: total price for all included parts in the requested currencyparts: per-part breakdown with their own price and the segments they cover
Usage:
- returned by journey pricing endpoints and attached to itinerary results
- selected when creating a booking (see
JourneyOfferSelectionandOfferSelectionInput) - per-part options (e.g.,
placeProperties,ancillaries) are configured on ReservationPart items
Notes:
- Some connections can be traveled without a reservation; such offers only have an AdmissionPart
- Sometimes reservations are included, in which case a
ReservationPartwith no price is returned - Long or mixed-operator journeys may include multiple
AdmissionPartandReservationPartitems, each covering different segments
Fields
idID!
parts[OfferPart!]!
priceMoney!
ticketDeliveryTicketDelivery
How the tickets for this offer can be delivered, and which method has been picked so far. Null when delivery information could not be established for this offer — the operator then delivers its own way and nothing can be picked.
memberOfOfferSet
The offers of one product sold across several legs. Select an offer from this set for every leg it covers, or nothing from it at all. Null on ordinary offers, which combine freely.
Two shapes exist. On some journeys the set is one priced combination and holds a single offer per leg — a return fare and its £0 companion — so those exact offers are the selection. On others every offer of every leg shares one set, because the journey is only sold whole: pick whichever offer you like on each leg, but book them all.
A set id names the product these offers are part of, for as long as the offers themselves last. It is not an address: offers are addressed by offer id, and a set id is never sent back. Two products priced identically are two sets, so equal prices are no reason to expect equal ids — and a refreshed journey is a new set of offers, which names its product with a new id.
OfferSet Object
A set of offers sold, and bookable, only as one product: every leg it covers is booked, each with an offer from the set.
It carries no offers of its own; it is an identity and nothing more. Two offers
belong to the same product when their memberOf.id matches.
Fields
idID!
OnboardAmenity Object
An onboard service or facility that may be available on a Segment.
Available onboard amenities may vary depending on service class, comfort class and accommodation.
Fields
Operator Object
Operator details
Fields
Order Object
Finalized order with confirmed bookings and issued tickets.
Represents a completed transaction where payment has been processed, offers have been confirmed, and tickets have been or are being issued. Orders are the final state of a booking and contain all travel documentation.
The reference field is typically used for customer service inquiries.
Fields
idID!
The order's order_… id, the form every operation taking an order id
accepts. Orders placed before these ids existed were handed out an id in
another form; node still resolves those.
createdAtZonedDateTime!
statusOrderStatus!
referenceString!
items[OrderItem!]
totalPriceMoney!
passengers[FullPassenger!]
metadataJSONObject
OrderConnection Object
Paginated orders list result
Fields
OrderEdge Object
An order edge in a paginated list
Fields
PageInfo Object
Pagination information
Fields
PassBundle Object
Bundle of rail passes and similar travel products.
Represents a collection of travel passes that can be purchased together, typically for multiple passengers or extended travel periods. These bundles provide access to train networks across multiple countries.
Pass structure:
class: "1stclass" (first class travel) or "2ndclass" (second class travel)product: "interrail-global-pass" (33 countries), "interrail-one-country-pass-sweden" (single country). A legacy "eurail-" key is accepted as an alias for its "interrail-" counterparttravelDayCount: Number of days the pass can be used for travel within the validity periodvalidityPeriod: Overall time window when the pass is valid
Pass types:
- Continuous passes:
travelDayCountis null (unlimited daily travel during validity period) - Flexi passes:
travelDayCountspecifies exact number of travel days within validity period
Fields
PassBundleOrderItem Object
A booked rail pass from a pass bundle offer, containing passenger details and pass information
Fields
PassBundleSelection Object
Selected Interrail bundle that is part of a booking
Fields
PassengerBundle Object
Passengers grouped by type for fare calculation and pass bundle allocation.
Represents a count of passengers of the same type that will be traveling together. This grouping is used to:
- Calculate group fares and discounts
- Allocate rail passes and other travel products
The count field represents the number of passengers of this specific type.
Fields
countInt!
typePassengerBundleType!
PassengerPlaceholder Object
The minium passenger details
Fields
PassengerProfile Object
A traveller's persistent details, offered to prefill a passenger.
Every detail is nullable: a traveller directory holds data we do not control,
so a detail it does not hold is simply absent, and a traveller with no
recognised cards has an empty travelCards list. The profile deliberately
carries no passenger type and no age — both depend on a travel date as
well as a birth date, and a profile belongs to no journey. Derive them from
birthDate once the date of departure is known.
Fields
firstNameString
The traveller's given name
lastNameString
The traveller's family name
titlePassengerTitle
The traveller's preferred title
birthDateDate
The traveller's date of birth
emailString
The traveller's email address
telString
The traveller's telephone number
nationalityString
The traveller's nationality
travelCards[TravelCard!]!
Discount cards the traveller holds, as far as we recognise them
costCenterCostCenter
The cost center the traveller's travel is billed to
PassengerRequirements Object
Details required for all passengers on a specific booking.
Defines which passenger information fields are mandatory for a particular booking. Requirements are determined by ticketing providers and vary depending on the operator being used.
Fields
PdfTicket Object
Ticket issued in PDF format for download
Fields
urlString!
PlacePreference Object
Possible place preferences
Fields
PlaceProperty Object
Option relating to the seating arrangement and other aspects of the journey.
Allows passengers to specify preferences for their travel experience, such as seat location, cabin type, or special requirements. These properties can be required (mandatory selection) or optional (preference-based).
Common property types:
- "GENDER": Segregated cabin by gender
- "PLACE_OR_COMPARTMENT_LOCATION": Location of the place or compartment
- "SPECIAL_COMPARTMENT_TYPE": Special compartment type
The availableOptions list shows all possible choices, while selectedOption indicates the passenger's current preference.
Fields
idID!
typeString!
requiredBoolean
availableOptions[PlacePropertyOption!]!
selectedOptionPlacePropertyOption
PlacePropertyOption Object
An option for a place property.
Represents a specific choice within a place property category. These options are what passengers can select from when choosing their preferences.
Examples by property type:
- GENDER: "MEN", "LADIES", "MIXED"
- PLACE_OR_COMPARTMENT_LOCATION: "WINDOW", "AISLE", "FRONT", "BACK"
- SPECIAL_COMPARTMENT_TYPE: "EASY_ACCESS", "WITHOUT_ANIMALS", "QUIET_ZONE"
The value field contains the standardized identifier for the option, while the id field provides a unique reference for selection tracking.
Fields
PlanningPeriod Object
Period for which a serivce is scheduled to run
Fields
startDateDate!
endDateDate!
bitfieldString!
A bitfield string representation of the days of service encoded as a hexadecimal string.
Each bit in the bitfield corresponds to a specific day, starting from the
startDate and ending on the endDate. Each hexadecimal character represents
4 days (bits).
Bit interpretation:
- Bit 0 = startDate
- Bit 1 = startDate + 1 day
- Bit 2 = startDate + 2 days
- etc.
Examples:
- "FF" = 8 days of service (11111111 in binary)
- "F0" = First 4 days of service (11110000 in binary)
- "0F" = Last 4 days of service (00001111 in binary)
- "AA" = Every other day (10101010 in binary)
To decode: Convert hex to binary, each 1 represents a day with service.
Product Object
A product we sell, such as a particular rail pass.
Fields
keyString!
The product's key, e.g. interrail-global-pass.
Stable and safe to hardcode: this is the value the pass bundle filter accepts
as its product and the value a pass bundle reports as its product.
nameString!
The product's name.
Whatever name the product carries in our catalogue, in no guaranteed language. Suitable as a fallback label; supply your own copy where you need it localised or on-brand.
RateLimit Object
Rate limit imposed for an agent to prevent API abuse.
Implements rate limiting to ensure fair usage of the API across all agents and to protect system resources from excessive requests.
When remaining reaches 0, requests are rejected until resetAt. Specific limits are determined by the commercial agreement with each agent.
Fields
Refund Object
A refund record capturing the execution of refund items for an order.
Fields
RefundableOfferItem Object
Contains the corresponding offer part of the refundable item
Fields
idID!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
refundParts[BookedOfferPart!]!
The offer parts that will be refunded
RefundablePassItem Object
Contains the corresponding pass item of the refundable item
Fields
idID!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
passItemPassBundleOrderItem
The pass item that will be refunded
RefundOfferItem Object
Contains the corresponding offer part of the refund item
Fields
idID!
stateRefundItemState!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
refundParts[BookedOfferPart!]!
The offer parts that will be refunded
RefundPassItem Object
Contains the corresponding pass item of the refund item
Fields
idID!
stateRefundItemState!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
passItemPassBundleOrderItem
The pass item that will be refunded
ReservationPart Object
The reservation part of an offer.
Represents the seat/berth reservation(s) and related options for the covered
segments. May expose configurable placeProperties (e.g., window/aisle,
quiet-zone) and optional ancillaries (e.g., luggage, meals). price reflects
the reservation cost for the part; the offer total is on Offer.price.
Fields
idID!
conditions[Condition!]!
Everything the provider stated about this part: refund and exchange rules
(ReturnCondition), the dates the ticket may be used on (ValidityCondition)
and other rules of use (TravelCondition), in that order. Render every
entry's description; see Condition for how to treat the kinds.
flexibilityFlexibility!
accommodationAccommodation!
placeProperties[PlaceProperty!]
placeAssignments[PlaceAssignment!]
ancillaries[Ancillary!]
serviceClassServiceClass!
comfortClassString
segments[Segment!]!
priceMoney
includedBoolean!
Whether this reservation part is included in the offer price
optionalBoolean!
Whether this reservation part can be included or excluded by the user
ReturnCondition Object
A refund or exchange rule for the ticket. type says which of the two it is,
timeframe until when the rule applies, and description is the rule in
words.
Fields
descriptionString!
typeConditionType!
Whether this is a refund or an exchange rule. A subset of ConditionType:
only ever REFUND, EXCHANGE or UNKNOWN.
timeframeReturnConditionTimeframe!
SalesAgent Object
An authorized agent interacting with the API
Fields
uidString!
emailString
telString
paymentMethodPaymentMethod!
rateLimits[RateLimit!]!
costCenters[CostCenter!]!
SeatAssignment Object
A seat assignment for a passenger
Fields
SeatMap Object
A map of seats for each coach
Fields
coaches[SeatMapCoach!]!
SeatMapCoach Object
A coach with seats
Fields
identifierString
seats[SeatMapSeat!]!
features[SeatMapFeature!]!
Facilities marked on the floor plan, such as toilets, exits and bicycle spaces
floorPlanSeatMapFloorPlan!
SeatMapFeature Object
A facility marked on a coach's floor plan
Fields
SeatMapFloorPlan Object
The floor plan of a coach, drawn landscape with the direction of travel to the left. Seats and features are positioned by their top-left corner in the plan's pixels.
Fields
SeatMapSeat Object
A seat on a coach
Fields
xposInt!
yposInt!
widthInt!
heightInt!
identifierString!
availabilityPlaceAvailability!
orientationInt
The way the seat faces, in degrees clockwise from the direction of travel on the floor plan: 0 faces the direction of travel, 180 faces away from it. Null when the provider doesn't say.
reversibleBoolean
Whether the seat can be turned to face either way, in which case orientation
is only how it is set. Null when the provider doesn't say.
Segment Object
Individual train segment representing a single physical train journey between two stops.
A segment is the atomic unit of travel - it represents one train/bus/ferry that
travels from origin to destination, possibly with intermediate stops but no
change of transport. Multiple segments can be combined to form an individual
journey leg, see SegmentCollection.
Fields
SegmentCollection Object
A collection of connected segments that form a logical journey leg.
Represents a sequence of segments that:
- Share the same availability status
- Can be booked together
- Have common offer options
- Form a continuous path between major stops
Used to group related segments together for pricing and booking purposes.
Fields
statusSegmentCollectionStatus!
segments[Segment!]
offers[Offer!]
availabilityAvailability
planningPeriodPlanningPeriod
polylines[String!]
Strings representing series of Positions encoded using the Google Maps Polyline algorithm.
May require decoding. See https://developers.google.com/maps/documentation/utilities/polylinealgorithm
SelectedFare Object
The selected fare of a journey offer
Fields
SelfServiceResource Object
Resource that provides a self-service link for customers to manage their booking on the provider's website
Fields
urlString!
metadataJSONObject
Metadata about the self-service resource, e.g. the booking number and email
ServiceBrand Object
The brand of the service
Fields
SmartJourney Object
A journey that optimizes for comfort by limiting daily travel time.
For short distances, provides direct connections when available. For longer routes, automatically segments the journey into multiple days to avoid excessively long travel times. This ensures passenger comfort and builds in buffer time in case of disruptions.
Segmentation logic considers factors like night trains, connection times, and time of day to determine whether splitting into multiple days would improve the overall experience.
This is the default journey type returned by the API.
Typical use cases:
- Long-distance trips that would be exhausting in a single day
- Routes where overnight breaks improve reliability
- Itineraries benefiting from night trains or natural break points
Fields
Stopover Object
Location for an overnight stopover
Fields
StripePayment Object
Payment using Stripe
Fields
TicketClass Object
The class of an available ticket, combining comfort and service levels.
Represents the quality and amenities available for a specific fare option. The comfortClass provides operator-specific classification (e.g., "1st", "2nd", "Premium"), while serviceClass gives a normalized comparison across different operators.
Examples:
- comfortClass: "1st", serviceClass: HIGH (First class with premium service)
- comfortClass: "2nd", serviceClass: STANDARD (Second class with standard service)
- comfortClass: "Premium", serviceClass: BEST (Premium class with best available service)
- comfortClass: "Economy", serviceClass: BASIC (Economy class with basic service)
Fields
comfortClassString
serviceClassServiceClass!
TicketDelivery Object
The ticket delivery choice for an offer.
Record a pick with the setTicketDelivery mutation, before creating the order.
Fields
availableOptions[TicketDeliveryOption!]!
The ways this offer's tickets can be issued. Never empty — an offer with no
established delivery information carries no ticketDelivery at all — but it
can hold a single option, meaning delivery is known and there is nothing to
pick.
selectedOptionTicketDeliveryOption
The recorded pick, or null when nothing has been picked yet — in which case
the operator applies its own default when the order is placed. Always one of
availableOptions.
TicketDeliveryOption Object
One way an offer's tickets can be delivered.
Fields
methodTicketDeliveryMethod!
How the tickets are handed to the traveller.
TicketOnDeparture Object
Ticket which can be retrieved on departure
Fields
TravelCard Object
A travel/discount card held by a passenger.
Represents loyalty, discount, or rail cards that may entitle the passenger to reduced fares. Examples include BahnCard (Germany), Halbtax (Switzerland), Carte Avantage (France), or Interrail.
Use the travelCardOptions query to discover available cards and their
required input fields.
Fields
TravelCardOption Object
An available travel card type that passengers can hold.
Use the code field when constructing a TravelCardInput and consult
inputFields to determine which additional fields are needed.
Fields
codeString!
Unique card type code
nameString!
Human-readable name of the card
inputFields[CardFieldRequirement!]!
Fields required when using this card type
TravelCondition Object
A rule about how the ticket may be used, other than the dates it is valid on
(those are a ValidityCondition). type says what kind of rule it is,
description is always the complete text, and url is set when a web page
holds the full wording of this specific rule. Render description; when url
is present, make it a link.
Fields
descriptionString!
typeConditionType!
What kind of rule this is. A subset of ConditionType: only ever ROUTE,
TRAIN_BOUND or RESTRICTION.
urlString
Web page holding the complete wording of this condition, or null when
there is none. Show it as a link, labelled by description. Today only
RESTRICTION conditions carry one.
User Object
The authenticated end user, as identified by their user token (JWT)
Fields
idID!
The user's unique id
emailString!
The user's email address
profilePassengerProfile
The user's travel profile, for prefilling their passenger details.
Null when the sales agent keeps no traveller directory, when no profile in it belongs to this user, or when the directory could not be reached. None of those is an error — ask the traveller for their details instead.
ValidityCondition Object
The dates on which the ticket may be used. validFrom and validUntil are
inclusive calendar dates in the operator's local time zone, and they are
definite: travel may start on validFrom and no later than validUntil.
There is deliberately no time of day. Operators let the last valid day run on
into the following morning — UK National Rail until 04:29, Deutsche Bahn
Flexpreis until 10:00 — and they differ on what that overrun permits (starting
a journey, or only finishing one), so it is never encoded in these dates;
where a provider states it, it is in description. Do not convert the dates
to timestamps or shift them between time zones. A part with a TRAIN_BOUND
TravelCondition never has a ValidityCondition: the booked departure is its
validity. A part with neither has a provider that did not state a validity
window; it is not valid indefinitely.
Fields
descriptionString!
validFromDate!
First day, inclusive, on which travel may start. A calendar date in the operator's local time zone — for a ticket bought for a specific outbound date this is that date. Not a timestamp; do not attach a time or a time zone.
validUntilDate!
Last day, inclusive, on which travel may start; equal to validFrom for a
ticket valid on one day only. A calendar date in the operator's local time
zone. Operators extend this day into the following morning (UK National Rail
until 04:29, Deutsche Bahn Flexpreis until 10:00) and differ on what that
extension permits, so it is deliberately not part of this value; look in
description for it.
breakOfJourneyBoolean
Whether the passenger may leave the station partway through the journey and
continue later on the same ticket, within the validity dates. true:
allowed. false: not allowed — the ticket buys one continuous journey.
null: the provider did not say; treat as unknown, never as allowed. UK
fares state this per ticket type; many other providers only imply it through
the fare family, and those arrive as null.
Interfaces
BookedOfferPart Interface
One part that makes up a booked offer.
Each part references the exact segments it applies to. The optional price
reflects the original cost of this part.
Possible types
BookedAdmissionPartBookedReservationPart
Fields
Condition Interface
A rule attached to an offer part about using, refunding or exchanging the
ticket. Every condition carries description: complete, human-readable text
that is always safe to show on its own. Tell the kinds apart by __typename
and read their typed fields through inline fragments
(... on ValidityCondition { validFrom validUntil }). New kinds may be added
over time: render description for any __typename you do not recognise
rather than dropping the entry. The list holds only what the provider stated —
the absence of a kind (no ValidityCondition, no TRAIN_BOUND) means the
provider did not say, never that the rule does not apply.
type and timeframe sit on the interface only so that selections written
against the previous [ReturnCondition!]! shape keep validating; see their
deprecation reasons.
Possible types
ReturnConditionTravelConditionValidityCondition
Fields
descriptionString!
Fare Interface
Fare offer for given itinerary item
Possible types
BookingFareJourneyFareSelectedFare
Fields
Journey Interface
Journey result produced by any given search algorithm
Possible types
BlueprintJourneyJourneyOfferNonStopJourneySmartJourney
Fields
Node Interface
Any unique resource with an ID
Possible types
AccessTokenBlueprintJourneyBookingBookingFareJourneyFareJourneyOfferNoChargeRedirectNonStopJourneyOfferOrderPassBundlePlacePreferenceRefundSelectedFareSmartJourneyStripePayment
Fields
idID!
OfferPart Interface
One part that makes up an offer.
Each part references the exact segments it applies to. The optional price
reflects the cost of this part; the overall total is reported on
Offer.price.
Possible types
Fields
Passenger Interface
A passenger with minimal details
Possible types
FullPassengerPassengerPlaceholder
Fields
Payment Interface
Represents a payment that needs to be processed to complete an order. The payment interface defines the common fields shared across different payment methods:
id: Unique identifier for the paymenturl: URL where the customer can complete the payment
Different payment implementations (like StripePayment or NoChargeRedirect)
may provide additional fields specific to their payment flow.
The payment URL typically redirects to a payment page hosted by All Aboard where the customer can securely enter their payment details.
Possible types
Fields
PlaceAssignment Interface
A place assignment for a passenger
Possible types
Fields
passengerPassenger!
Placement Interface
A placement on a coach, eg. a seat or a bed
Possible types
Fields
availabilityPlaceAvailability!
RefundableItem Interface
Represents a potential refund opportunity before execution
Possible types
RefundableOfferItemRefundablePassItem
Fields
idID!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
RefundItem Interface
Represents a refund line item after execution has been initiated
Possible types
Fields
idID!
stateRefundItemState!
descriptionString!
amountMoney
The amount that will be refunded
passengers[FullPassenger!]
The passengers this item covers, when known
Stop Interface
Generic train stop
Possible types
Fields
nameString!
Enums
AccessTokenCapability Enum
What an access token may do on the order it is bound to.
READ is implied by WRITE, so a token minted with [WRITE] comes back
carrying both — a credential that may refund an order may read it.
Values
READ
Read the order, its bookings, its refunds and its payments.
WRITE
Start a refund of the order, and pay for it by card.
AccommodationType Enum
The type of accommodation available
Values
SEAT
Seat in a seated area
COUCHETTE
Bed in a couchette cabin
BERTH
Bed in a comfortable sleeper cabin
UNKNOWN
Accommodation is unknown
AvailabilityStatus Enum
The current availability of a journey
Values
LOADING
The request is loading
AVAILABLE
The request was successful
UNKNOWN
An unexpected error occurred
SOLD_OUT
Fares are sold out
ConditionType Enum
Transitional union of ReturnType and the travel-condition kinds, present only
while Condition.type exists on the interface. Each concrete type returns only
its own values: ReturnCondition REFUND, EXCHANGE or UNKNOWN;
TravelCondition ROUTE, TRAIN_BOUND or RESTRICTION; ValidityCondition has no
meaningful type and returns UNKNOWN. The end state removes type from
Condition, narrows ReturnCondition.type back to ReturnType and
TravelCondition.type to TravelConditionType, and retires this enum. Do not
write new code against it: select type through ... on ReturnCondition or
... on TravelCondition.
Values
EXCHANGE
An exchange rule; only returned by ReturnCondition.
REFUND
A refund rule; only returned by ReturnCondition.
UNKNOWN
The provider stated a refund or exchange rule without saying which — or the
condition is a ValidityCondition, which has no type.
ROUTE
The ticket is only valid on a particular route or with particular operators;
description says which. Example: "Only valid on booked London Northwestern
Railway and Northern services."
TRAIN_BOUND
The ticket is only valid on the specific train(s) it was booked for; the
passenger may not take an earlier or later service. Typical of UK Advance
fares and Deutsche Bahn Sparpreis. A part carrying this never also carries a
ValidityCondition. A train-bound ticket cannot be broken: the passenger
travels the booked trains and changes only at the booked connections, so no
separate break-of-journey statement is made.
RESTRICTION
Time-of-day and day-of-week limits on when the ticket may be used — peak-hour
exclusions and the like — too detailed to repeat inline. description points
at the full rules and url links to the page holding them.
FieldRequirement Enum
Whether a travel card field is required
Values
ALWAYS
The field must always be provided
CONDITIONAL
The field is required under certain conditions
OPTIONAL
The field is optional
Flexibility Enum
Flexibility of a fare
Values
NON_FLEX
No refunds or exchanges
SEMI_FLEX
Partly refundable or exchangeable
FULL_FLEX
Fully refundable or exchangeable
UNKNOWN
Flexibility is unknown
JourneyStatus Enum
The current status for a journey result
Values
LOADING
SUCCESS
ERROR
JourneyType Enum
Type of journey
Values
BLUEPRINT
Journeys built from predefined itinerary blueprints (curated or editorial routes). May include planned stopovers and specific paths.
NON_STOP
Fastest end-to-end journeys without planned overnight stopovers. Transfers may occur, but no intentional multi-day segments are included.
SMART
Comfort-optimized journeys that may split long routes across days to limit daily travel time and improve overall experience. Default type.
OnboardAmenityCategory Enum
Categories of amenities describing onboard services and facilities
Values
SNACKS
MEAL
SLEEP
WIFI
TOILET
WHEELCHAIR
BIKE
AC
SEAT
KIDS
CHARGING
OrderStatus Enum
Current status of an order
Values
CONFIRMED
Order is confirmed
PENDING
Order is pending confirmation
FAILED
The order has failed
REFUNDED
All refundable items have been refunded
PARTIALLY_REFUNDED
Some refundable items have been refunded
REFUND_FAILED
The refund attempt failed
VOIDED
The order has been voided
UNKNOWN
Unknown state
PassengerBundleType Enum
The resulting product type definition for a passenger
Values
ADULT
SENIOR
YOUTH
CHILD
PassengerTitle Enum
The perferred title of a passenger
Values
MR
MS
MX
PassengerType Enum
The type of passenger
Values
ADULT
Ages 28-59
YOUTH
Ages 0-27
SENIOR
Ages 60+
PaymentMethod Enum
Valid agent payment method
Values
INVOICE
WALLET
STRIPE
PlaceAvailability Enum
The availability of a place, eg. seat or bed
Values
AVAILABLE
UNAVAILABLE
UNKNOWN
PriceCategory Enum
The category of a price
Values
PUBLIC
Publicly avaialble price
CONTRACT
The price is offered under a supplier contract
RateLimitUnit Enum
The unit for a given rate limit
Values
MINUTE
HOUR
DAY
RefundItemState Enum
State of a refund item
Values
SUCCEEDED
PENDING
ERROR
RefundState Enum
State of a refund
Values
SUCCEEDED
PENDING
ERROR
ReturnConditionTimeframe Enum
Indicates if, and during what timeframe, an offer part is returnable/exchangeable. Use this field to signal:
- If the offer part is refundable/exchangeable or not
- If so, the relevant period (e.g. only before departure, or at any time) Consult the accompanying description for refund/exchange details (e.g. % refunded, fees).
Values
ALWAYS
The offer part is refundable/exchangeable at any time, as described in the condition.
BEFORE_DEPARTURE
The offer part is refundable/exchangeable only up to the point of departure. See description for details.
NEVER
The offer part is not refundable/exchangeable.
UNKNOWN
It is uncertain or varies when the offer part is refundable/exchangeable; see description for specifics.
ReturnType Enum
Type of return covered by a return policy
Values
EXCHANGE
REFUND
UNKNOWN
SeatMapFeatureType Enum
The kind of facility a floor plan marks, named after OSDM's Graphics Items code list. Expect values to be added.
Values
TOILET_AREA
ENTRY_EXIT
BICYCLE_AREA
WHEELCHAIR_SPACE
PRAM_AREA
LUGGAGE_AREA
BABY_CARE_TABLE
PLAYGROUND_AREA
RESTAURANT_AREA
SegmentCollectionStatus Enum
Status indicating whether a segment collection was successfully loaded or encountered an error
Values
LOADING
The request is loading
SUCCESS
The request was successful
INDETERMINATE
Status could not be determined due to an error with a prior connection
UNKNOWN
An unexpected error occurred
ONE_DAY
Allow at least one day from todays date
NO_FARES
No fares available for the requested connection
NO_TIMETABLE
No timetable available for the requested date
UNABLE_TO_SELL
No availability
OUTSIDE_TIMETABLE
The requested date falls outside current timetable planning period
PREBOOK_NOT_POSSIBLE
Online prebook is not possible due to sales restrictions
ServiceClass Enum
Normalized class of service
Values
BEST
Best class available, premium comfort with top-tier amenities and exclusive services
HIGH
Standard first class, high comfort with enhanced seating and additional perks
STANDARD
Standard second class, balanced service with essential comfort and amenities
BASIC
Most economical class available, minimal service focused on affordability and essential needs
UNKNOWN
Service class is not known
SortDirection Enum
Sort direction for ordering results
Values
ASC
DESC
TicketDeliveryMethod Enum
How the tickets for an offer are handed to the traveller
Values
E_TICKET
Delivered electronically; there is nothing to collect before travel.
TICKET_ON_DEPARTURE
Collected from a ticket machine at the departure station before travel, using the collection reference issued with the order.
Transport Enum
The mode of transport
Values
NIGHT_TRAIN
TRAIN
BUS
FERRY
NIGHT_BUS
Unions
BookingSelection Union
Selections that can be part of a booking
Possible types
ItineraryItem Union
Items that can make up the itinerary of a Journey
Possible types
OrderItem Union
Items that can be part of an order
Possible types
OrderResource Union
A resource associated with an order
Possible types
CheckInResourceFileResourcePdfTicketSelfServiceResourceTicketOnDeparture
PlaceMap Union
A map of places on e.g. a leg of a journey
Possible types
Scalars
Boolean Scalar
The Boolean scalar type represents true or false.
Date Scalar
Date string (ISO 8601 – YYYY-MM-DD)
DateTime Scalar
Naive date and time string, seconds omitted (ISO 8601 – YYYY-MM-DDThh:mm)
Duration Scalar
ISO 8601 formatted string, e.g. PT2H15M, P2D, P1M
Float Scalar
The Float scalar type represents signed double-precision fractional values as specified by IEEE 754.
ID Scalar
The ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as "4") or integer (such as 4) input value will be accepted as an ID.
Int Scalar
The Int scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
JSONObject Scalar
The JSONObject scalar type represents JSON objects as specified by ECMA-404.
String Scalar
The String scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
ZonedDateTime Scalar
A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the date-time format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.
Inputs
AccessTokenRestrictionsInput Input
What an access token is narrowed to. Exactly one order today; the shape is an object so a later narrowing is an added field rather than a breaking change.
Fields
orderIdID
The order the token may reach, as its order_… id.
Nullable only so that omitting it fails with INVALID_RESTRICTIONS rather
than as a schema validation error — a token bound to nothing is never
minted. An order that does not exist, and one the caller may not read, both
fail with NOT_FOUND.
AddAncillaryInput Input
Ancillary to add to a booking for a given passenger
Fields
BookingSelectionInput Input
Selection for a booking
Fields
offerOfferSelectionInput
CostCenterInput Input
Selects a cost center to bill this passenger's travel against
Fields
FareSelectionInput Input
Selection of fare for a journey
Fields
FullPassengerInput Input
Full passenger details required to complete a booking.
Represents the complete set of passenger data that may be required by
ticketing providers and operators. Exactly one passenger per booking must be
marked as the contact person using isContactPerson: true. The contact person
must provide both email and tel so they can receive operational updates.
Notes:
- Only one passenger should be marked as contact person per booking
- When
isContactPersonis true,emailandtelmust be provided - Other fields may be required depending on operator (see
PassengerRequirements)
Fields
emailString
telString
Phone number with country code (E.123)
birthDateDate
firstNameString
lastNameString
isContactPersonBoolean
Mark this passenger as the booking contact person; requires email, tel
titlePassengerTitle
countryResidenceString
nationalityString
passportNumberString
placeOfBirthCityString
placeOfBirthCountryString
travelCards[TravelCardInput!]
Travel cards held by the passenger. Fixed when the booking is created. On updateBooking either leave the field out or echo the stored cards unchanged; any other value is rejected with TRAVEL_CARDS_IMMUTABLE, and null is read as an empty list rather than as an omission
GeoJSONInput Input
A point in GeoJSON format, following RFC 7946 and using the WGS84 coordinate system.
Coordinates are given as [longitude, latitude] (note the order), and type is
always "Point".
Examples:
- London: { type: "Point", coordinates: [-0.1278, 51.5074] }
- Stockholm: { type: "Point", coordinates: [18.0686, 59.3293] }
Fields
JourneyFilterInput Input
Filter for journey search results by journey type.
Use this to restrict which journey variants are returned. Supported types:
- SMART: Comfort-optimized journeys; may split long routes across days. Default journey type returned by the API.
- BLUEPRINT: Journeys based on predefined itinerary blueprints (curated or editorial routes), can include planned stopovers.
- NON_STOP: Fastest end-to-end journeys without planned overnight stopovers.
You can combine multiple types to retrieve several variants at once.
Fields
types[JourneyType!]
LocationInput Input
Identifies a location.
Holds the location's uid today. Future identifiers will be added as further
optional fields rather than as new arguments.
Fields
Unique identifier of the location
LocationsFilter Input
Narrows and orders locations. Every field is optional, and which of query
and near are given decides the order: query ranks by relevance, near
without query orders by distance, and neither keeps the stable walk order.
countryCode and isMeta only narrow.
Fields
queryString
Text to find locations by: a name, part of one, or an alias, optionally with an English country name ("paris france"). Case and diacritics are ignored, so "Koln" finds "Köln". Every word has to match. Best matches first: the whole text equal to a name or alias, then starting one, then each word starting a word, then close misspellings. Among equal matches a city comes before its stations and a popular location before a rare one. Empty or blank text is no text.
countryCodeString
ISO 3166-1 alpha-2 country the locations must be in.
nearGeoJSONInput
A GeoJSON Point, [lng, lat]. Without query the locations are ordered by
their distance from it; with query it only breaks ties between equally
good matches.
radiusInt
With near: leaves out locations further away than this many metres.
isMetaBoolean
Only cities (true) or only single stations and stops (false).
OfferSelectionInput Input
Selection of offer for a journey
Fields
PassBundleFilterInput Input
Filter for filtering pass bundles by various criteria.
Supported filters:
- product: Filter by specific pass product type, e.g. "interrail-global-pass"
- class: Filter by travel class (e.g. "1stclass" or "2ndclass")
- campaignCode: Filter by promotional campaign code, e.g. "INTERRAIL_2025"
Use this to narrow down pass bundle results when searching for available passes.
Fields
PassengerPlaceholderInput Input
Input type for basic passenger details. When specifying a passenger's age, either:
- Provide the
birthDatefield with their date of birth, OR - Provide the
agefield with their age at time of travel
For passenger types YOUTH and SENIOR, one of these age fields must be
provided to validate eligibility for age-based fares and discounts.
For the ADULT passenger type, age fields are optional.
Fields
typePassengerType
birthDateDate
ageInt
Age at the time of travel
travelCards[TravelCardInput!]
Travel cards held by the passenger. They are part of the price, so pass the same cards when pricing the journey and when creating the booking
costCenterCostCenterInput
Cost center to bill this passenger against; defaults to the agent's default cost center
PassPassengerInput Input
Passenger details for passholder
Fields
PlacePropertyInput Input
Place property to update
Fields
PlaceSelectionInput Input
A place selection for a passenger
Fields
RemoveAncillaryInput Input
Ancillary selection to remove from a booking
Fields
SeatSelectionInput Input
A seat selection for a passenger
Fields
TravelCardInput Input
Input for attaching a travel card to a passenger
Fields
ViaInput Input
Via stopover for a journey to break up long trips.
Allows passengers to specify intermediate locations where they want to stop and spend time before continuing their journey. This is useful for long-distance travel where passengers want to explore cities along the way or break up overnight journeys.
Field requirements:
- uid: Required - the location UID where the stopover occurs
- duration: Optional - how long to stay (e.g., "P2D" for 2 days) If not specified, the journey will simply route via that location with a change of trains (no extended stopover)