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

See: https://docs.allaboard.eu/tickets/

Arguments

originLocationInput!required

Origin location

destinationLocationInput!required

Destination location

dateDate!required

Date of departure

Optional filter for journey search

via[ViaInput!]

Optional via stopovers

Passenger details required for availability

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/tickets/journey-offer

Arguments

journeyIdID!required

Id of the Journey to get fares for

passengers[PassengerPlaceholderInput!]!required

Passenger details

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/tickets/journey-offer

Arguments

outboundJourneyIdID!required

Id of the outbound Journey to get fares for

inboundJourneyIdID!required

Id of the inbound Journey to get fares for, from a search in the opposite direction

passengers[PassengerPlaceholderInput!]!required

Passenger details, applying to both directions

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/blueprints/

Arguments

blueprintID!required

Blueprint id to get journey for

dateDate!required

Date of departure

Passenger details required for availability

currencyString= "EUR"

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

See: https://docs.allaboard.eu/passes/

Arguments

passengers[PassPassengerInput!]!required

Passenger details

departureDateDate

Planned departure date

Optional filter for pass bundles

currencyString= "EUR"

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

journeyOfferID!required

Id of journey offer to get pass bundles for

passengers[PassPassengerInput!]

Passenger details

Optional filter for pass bundles

currencyString= "EUR"

Currency to display prices in

getJourneyRatings ​

getJourneyRatings(journeys: [ID!]!): [Float!]!

Get comparative rating for journeys

Arguments

journeys[ID!]!required

List of journey ids

getTicketingFee ​

getTicketingFee( fares: [ID!] passBundle: ID currency: String ): Money

Get fee for issuing tickets

Arguments

fares[ID!]

List of fares to get ticketing fee for

passBundleID

Id of pass bundle to get ticketing fee for

currencyString= "EUR"

Currency to display prices in

orders ​

orders( after: String before: String first: Int last: Int query: String sort: SortDirection ): OrderConnection!

List orders

Arguments

afterString

Cursor to start listing from

beforeString

Cursor to end listing at

firstInt

Number of orders to return (head)

lastInt

Number of orders to return (tail)

queryString

Query to filter orders by, eg. reference, passenger names, email, etc.

sortSortDirection= DESC

Sort direction for ordering results

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

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 ​

node(id: ID!, currency: String): Node

Use this query to get anything that implements the Node interface. It's the recommended way to get entities based on their id.

See: https://docs.allaboard.eu/intro/node

Arguments

idID!required

Id of node

currencyString= "EUR"

Currency to display prices in

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 ​

placeMapForPart(offerId: ID!, partId: ID!): PlaceMap

Get a map of places for a given offer and part

Arguments

offerIdID!required

Id of offer

partIdID!required

Id of part

refundableItems ​

refundableItems(orderId: ID!): [RefundableItem!]!

Returns a list of refundable items that can be refunded

Arguments

orderIdID!required

Id of the order

refunds ​

refunds(orderId: ID!): [Refund!]!

List all executed refunds for an order

Arguments

orderIdID!required

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

currencyString= "EUR"

Currency to display prices in

partnerIdString

Partner id for tracking

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

idID!required

Id of booking to update

passengers[FullPassengerInput!]

Passenger details to update

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

idID!required

Id of part to update

bookingID!required

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 ​

setTicketDelivery(offerId: ID!, method: TicketDeliveryMethod!): Offer!

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

offerIdID!required

Id of the offer to set the delivery method for

methodTicketDeliveryMethod!required

The method of one of the offer's ticketDelivery.availableOptions

createPayment ​

createPayment( orderId: ID cancelUrl: String! successUrl: String! language: String ): Payment!

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.

See: https://docs.allaboard.eu/payments/

Arguments

orderIdID

Id of the order to pay for (from createOrder)

cancelUrlString!required

URL to redirect to in the case of payment cancellation

successUrlString!required

URI Template (RFC 6570) compliant string with {order} placeholder

languageString= "en"

Optional 2-letter language tag used to localise the payment page URL

createOrder ​

createOrder(booking: ID!, metadata: JSONObject): Order!

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.

See: https://docs.allaboard.eu/docs/orders

Arguments

bookingID!required

Id of booking to confirm

metadataJSONObject

JSON encoded string of metadata to attach to order

finalizeOrder ​

finalizeOrder(order: ID!): Order!

This will finalize an order and start issuing tickets.

See: https://docs.allaboard.eu/docs/orders

Arguments

orderID!required

Id of order to finalize

refundItems ​

refundItems(orderId: ID!, refundableItemIds: [ID!]!): Refund

Execute refunds for selected refundable items

Arguments

orderIdID!required

Id of the order to refund items from

refundableItemIds[ID!]!required

List of refundable item IDs to refund

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

restrictionsAccessTokenRestrictionsInput!required

What the token is narrowed to. Must name an order.

capabilities[AccessTokenCapability!]= [READ]

What the token may do. Omit it for [READ]; [WRITE] implies READ. An explicitly empty list fails with INVALID_CAPABILITIES.

ttlSecondsInt= 900

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

idID!required

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.

See: https://docs.allaboard.eu/tickets/

Arguments

originLocationInput!required

Origin location

destinationLocationInput!required

Destination location

dateDate!required

Date of departure

Optional filter for journey search

via[ViaInput!]

Optional via stopovers

Passenger details required for availability

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/tickets/journey-offer

Arguments

journeyIdID!required

Id of the Journey to get fares for

passengers[PassengerPlaceholderInput!]!required

Passenger details

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/tickets/journey-offer

Arguments

outboundJourneyIdID!required

Id of the outbound Journey to get fares for

inboundJourneyIdID!required

Id of the inbound Journey to get fares for, from a search in the opposite direction

passengers[PassengerPlaceholderInput!]!required

Passenger details, applying to both directions

currencyString= "EUR"

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.

See: https://docs.allaboard.eu/blueprints/

Arguments

blueprintID!required

Blueprint id to get journey for

dateDate!required

Date of departure

Passenger details required for availability

currencyString= "EUR"

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.

Implements Node

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.

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

descriptionString
subTypeString

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.

Implements OfferPart

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
priceMoney
selections[AncillarySelection!]!

AncillarySelection Object​

A selection of an ancillary service

Fields

idID!
passengerIdID!

AnonymousLocation Object​

A station where stops may be made but journeys cannot be planned from/to

Implements Stop

Fields

nameString!

Availability Object​

Ticket availablility

Fields

priceCategoryPriceCategory
accommodations[Accommodation!]
ticketClasses[TicketClass!]
priceFrom(currency: String)Money

BedAssignment Object​

A bed assignment for a passenger

Implements PlaceAssignment

Fields

passengerPassenger!
bedIdentifierString
coachIdentifierString
accommodationAccommodation

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

Implements Journey, Node

Fields

idID!
itinerary[ItineraryItem!]

BookedAdmissionPart Object​

A the part of a booked offer that is the admission

Implements BookedOfferPart

Fields

segments[Segment!]!
priceMoney

BookedReservationPart Object​

A part of a booked offer that is the reservation

Implements BookedOfferPart

Fields

segments[Segment!]!
priceMoney

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.

Implements Node

Fields

idID!
expiresAtDateTime
ticketingFeeMoney
totalPriceMoney
passengers[Passenger!]
selections[BookingSelection!]
termsAndConditions[String!]

BookingFare Object​

A bookable fare offer for a journey

Implements Fare, Node

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

nameString!
valueString!

CostCenter Object​

A cost center belonging to a sales agent, used for billing and payment routing

Fields

idID!
nameString!
defaultBoolean!
paymentMethodPaymentMethod!

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

nameString
typeString!
urlString!

FullPassenger Object​

All passenger details

Implements Passenger

Fields

idID!
firstNameString
lastNameString
ageInt
emailString
birthDateDate
countryResidenceString
isContactPersonBoolean
nationalityString
passportNumberString
placeOfBirthCityString
placeOfBirthCountryString
travelCards[TravelCard!]

GenericOrderItem Object​

An unspecified item in an order

Fields

descriptionString!
priceMoney!

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

typeString!
coordinates[Float!]!

JourneyFare Object​

A fare offer for a journey

Implements Fare, Node

Fields

idID!
nameString!
priceMoney!

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).

Implements Journey, Node

Fields

idID!
itinerary[ItineraryItem!]

JourneyOfferSelection Object​

Selected journey offer that is part of a booking

Fields

offers[Offer!]!

JourneyOrderItem Object​

A booked journey from a journey offer, containing segments, tickets and other resources

Fields

segments[Segment!]!
offerOffer!
resources[OrderResource!]

JourneySelection Object​

The journey selected for an offer

Fields

itinerary[ItineraryItem!]!

Location Object​

Known location from and to which journeys can be planned

Implements Stop

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

cursorString

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

amountInt!
currencyString!

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.

Implements Payment, Node

Fields

idID!
urlString!

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.

Implements Journey, Node

Fields

idID!
itinerary[ItineraryItem!]

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 currency
  • parts: 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 JourneyOfferSelection and OfferSelectionInput)
  • 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 ReservationPart with no price is returned
  • Long or mixed-operator journeys may include multiple AdmissionPart and ReservationPart items, each covering different segments

Implements Node

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

subCategoryString
descriptionString!

Operator Object​

Operator details

Fields

codeString

The unique identifier for the operator.

nameString!
image(format: String)FileResource

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.

Implements Node

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!
referenceString!
items[OrderItem!]
totalPriceMoney!
passengers[FullPassenger!]
metadataJSONObject

OrderConnection Object​

Paginated orders list result

Fields

edges[OrderEdge!]!
pageInfoPageInfo!
totalCountInt!

OrderEdge Object​

An order edge in a paginated list

Fields

nodeOrder!
cursorString

PageInfo Object​

Pagination information

Fields

hasNextPageBoolean!
hasPreviousPageBoolean!
startCursorString
endCursorString

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-" counterpart
  • travelDayCount: Number of days the pass can be used for travel within the validity period
  • validityPeriod: Overall time window when the pass is valid

Pass types:

  • Continuous passes: travelDayCount is null (unlimited daily travel during validity period)
  • Flexi passes: travelDayCount specifies exact number of travel days within validity period

Implements Node

Fields

idID!
classString
productString!
priceMoney!
passengers[PassengerBundle!]!
travelDayCountInt
validityPeriodDuration

PassBundleOrderItem Object​

A booked rail pass from a pass bundle offer, containing passenger details and pass information

Fields

passengerFullPassenger!
codeString
classString
productString!
priceMoney!
travelDayCountInt
validityPeriodDuration

PassBundleSelection Object​

Selected Interrail bundle that is part of a booking

Fields

productString!
classString
priceMoney!
passengers[PassengerBundle!]!
travelDayCountInt
validityPeriodDuration

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

PassengerPlaceholder Object​

The minium passenger details

Implements Passenger

Fields

idID!
ageInt
birthDateDate
travelCards[TravelCard!]

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

The traveller's preferred title

birthDateDate

The traveller's date of birth

emailString

The traveller's email address

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

countryResidenceBoolean!
dateOfBirthBoolean!
emailBoolean!
nationalityBoolean!
passportNumberBoolean!
placeOfBirthCityBoolean!
placeOfBirthCountryBoolean!
titleBoolean!
firstNameBoolean!
lastNameBoolean!

PdfTicket Object​

Ticket issued in PDF format for download

Fields

urlString!

PlacePreference Object​

Possible place preferences

Implements Node

Fields

idID!
nameString!
priceMoney

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

idID!
valueString!

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

limitInt!
remainingInt!
resetAtDateTime!
resourceString!

Refund Object​

A refund record capturing the execution of refund items for an order.

Implements Node

Fields

idID!
createdAtZonedDateTime!
items[RefundItem!]!

RefundableOfferItem Object​

Contains the corresponding offer part of the refundable item

Implements RefundableItem

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

Implements RefundableItem

Fields

idID!
descriptionString!
amountMoney

The amount that will be refunded

passengers[FullPassenger!]

The passengers this item covers, when known

The pass item that will be refunded

RefundOfferItem Object​

Contains the corresponding offer part of the refund item

Implements RefundItem

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

RefundPassItem Object​

Contains the corresponding pass item of the refund item

Implements RefundItem

Fields

idID!
descriptionString!
amountMoney

The amount that will be refunded

passengers[FullPassenger!]

The passengers this item covers, when known

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.

Implements OfferPart

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.

Implements Condition

Fields

descriptionString!

Whether this is a refund or an exchange rule. A subset of ConditionType: only ever REFUND, EXCHANGE or UNKNOWN.

SalesAgent Object​

An authorized agent interacting with the API

Fields

uidString!
emailString
paymentMethodPaymentMethod!
rateLimits[RateLimit!]!
costCenters[CostCenter!]!

SeatAssignment Object​

A seat assignment for a passenger

Implements PlaceAssignment

Fields

seatIdentifierString
coachIdentifierString
passengerPassenger!

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

SeatMapFeature Object​

A facility marked on a coach's floor plan

Fields

xposInt!
yposInt!
widthInt!
heightInt!

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

heightInt!
widthInt!

SeatMapSeat Object​

A seat on a coach

Implements Placement

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

originStop!
destinationStop!
departureAtDateTime!
arrivalAtDateTime!
durationInt!
transportTransport!
operatorOperator!
serviceBrandServiceBrand
identifierString
directionString
amenities[OnboardAmenity!]!

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

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

Implements Fare, Node

Fields

idID!
nameString!
priceMoney!
descriptionString
refundPolicies[String!]
placePreferencePlacePreference
compartmentTypeString

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

nameString!
codeString!
image(format: String)FileResource

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

Implements Journey, Node

Fields

idID!
itinerary[ItineraryItem!]

Stopover Object​

Location for an overnight stopover

Fields

locationLocation!
durationDuration

StripePayment Object​

Payment using Stripe

Implements Payment, Node

Fields

idID!
urlString!

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

How the tickets are handed to the traveller.

TicketOnDeparture Object​

Ticket which can be retrieved on departure

Fields

referenceString!

Ticket collection reference

descriptionString!

Instructions on how to retrieve the ticket

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

codeString!

Unique card type code

identifierString

Card number or other identifying value, if required by the card type

nameString!

Human-readable name of the card

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.

Implements Condition

Fields

descriptionString!

What kind of rule this is. A subset of ConditionType: only ever ROUTE, TRAIN_BOUND or RESTRICTION.

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

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.

Implements Condition

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

segments[Segment!]!
priceMoney

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

Implements Node

Possible types

BookingFareJourneyFareSelectedFare

Fields

idID!
nameString!
priceMoney!

Journey Interface​

Journey result produced by any given search algorithm

Implements Node

Possible types

BlueprintJourneyJourneyOfferNonStopJourneySmartJourney

Fields

idID!
itinerary[ItineraryItem!]

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

AdmissionPartReservationPart

Fields

segments[Segment!]!
priceMoney

Passenger Interface​

A passenger with minimal details

Possible types

FullPassengerPassengerPlaceholder

Fields

idID!
ageInt
birthDateDate
travelCards[TravelCard!]

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 payment
  • url: 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.

Implements Node

Possible types

NoChargeRedirectStripePayment

Fields

idID!
urlString!

PlaceAssignment Interface​

A place assignment for a passenger

Possible types

BedAssignmentSeatAssignment

Fields

passengerPassenger!

Placement Interface​

A placement on a coach, eg. a seat or a bed

Possible types

SeatMapSeat

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

RefundOfferItemRefundPassItem

Fields

idID!
descriptionString!
amountMoney

The amount that will be refunded

passengers[FullPassenger!]

The passengers this item covers, when known

Stop Interface​

Generic train stop

Possible types

AnonymousLocationLocation

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

JourneyOfferSelectionPassBundleSelection

ItineraryItem Union​

Items that can make up the itinerary of a Journey

Possible types

SegmentCollectionStopover

OrderItem Union​

Items that can be part of an order

Possible types

GenericOrderItemJourneyOrderItemPassBundleOrderItem

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

SeatMap

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

ancillaryIdID!required
passengerIdID!required

BookingSelectionInput Input​

Selection for a booking

Fields

CostCenterInput Input​

Selects a cost center to bill this passenger's travel against

Fields

idID!required

FareSelectionInput Input​

Selection of fare for a journey

Fields

idID!required
placePreferenceID
compartmentTypeString

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 isContactPerson is true, email and tel must be provided
  • Other fields may be required depending on operator (see PassengerRequirements)

Fields

idID!required
emailString

Phone number with country code (E.123)

birthDateDate
firstNameString
lastNameString
isContactPersonBoolean

Mark this passenger as the booking contact person; requires email, tel

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

typeString!required
coordinates[Float!]!required

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

uidID!required

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.

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

idID!required

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

productString
classString
campaignCodeString

PassengerPlaceholderInput Input​

Input type for basic passenger details. When specifying a passenger's age, either:

  1. Provide the birthDate field with their date of birth, OR
  2. Provide the age field 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

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

ageInt
birthDateDate
countryResidenceString
nationalityString

PlacePropertyInput Input​

Place property to update

Fields

optionIdID!required
propertyIdID!required

PlaceSelectionInput Input​

A place selection for a passenger

Fields

RemoveAncillaryInput Input​

Ancillary selection to remove from a booking

Fields

idID!required

SeatSelectionInput Input​

A seat selection for a passenger

Fields

coachIdentifierString
seatIdentifierString!required
passengerIdID!required

TravelCardInput Input​

Input for attaching a travel card to a passenger

Fields

codeString!required

Card type code

identifierString

Card number or other identifying value, when required by the card type

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)

Fields

uidID!required
durationDuration