Galileo connected workflows
Galileo software for governed booking, ticketing and servicing
Run Travelport Galileo content through one controlled workflow: search, pricing, PNR creation, ticketing, changes and refunds, with validation before payment, approvals where risk is highest and a log of every action.
- Galileo 1G on Travelport
- Ticketing and approval rules
- Changes, refunds and reissues
- Audit trail for every action
How a Galileo rollout works
Plan Galileo as one operational system
Galileo projects stall when teams cannot see the dependencies. We plan supplier scope, the booking flow, the servicing flow and reporting together, write each transaction as a clear sequence of states, and release in stages so exceptions are handled on purpose rather than by whoever is on shift.
- Define the Galileo transactions in scope: search, pricing, booking, ticketing and servicing
- Set credentials and roles per market, branch and environment
- Agree timeouts, retries, validation gates and approval rules
- Test journeys and exceptions in pre-production
- Go live in stages with runbooks and a rollback path
- Environment
- Pre-production
- PCC
- 1G · ••••
- API credentials
- API key: ••••••
- Approval
- Supervisor for voids and refunds
- Auto-ticketing
- Issue when price and fare rules are confirmed
Booking and servicing
Galileo bookings that stay correct after checkout
Responses are normalised, checked again before payment and placed on the right queue, so agents spend their time on exceptions instead of routine steps.
- 1GLHR → JFK · 2 adultsSchedule change · new times accepted–total
- GDSDXB → KHI · 1 adultRefund request · fare rules checked–total
- CDG → BKK · 1 adultPrice and fare rules confirmed–total
Connectivity and routing
Routing rules, credential pools and isolated environments for each Galileo connection.
Data normalisation
Fares, taxes, baggage and penalties mapped into one consistent format for the booking engine.
Validation before payment
Itinerary, passenger types, fare basis and penalties checked before the card is charged.
Drift detection
Price or availability changes between search and booking shown clearly, with a safe fallback.
Safe retries
Timeouts and retries with idempotency keys, so an unstable connection never creates a duplicate booking.
Servicing console
Changes, refunds, reissues and schedule updates handled from one place, with customer messages.
Booking lifecycle
Search, book, ticket, service, reconcile
Every Galileo booking follows the same sequence, so each agent works the same way under the same policy.
Search and price
Live availability and fares, priced again before checkout.
Validate fare rules
Baggage, penalties and ticketing limits checked before payment.
Create the PNR
Traveller and payment details confirmed, record locator stored.
Ticket
Issued automatically when rules allow, or held for approval.
Service
Changes, voids, refunds and reissues with fee rules and approvals.
Reconcile
Invoices, commissions and settlement exports matched to bookings.
Around Galileo
Galileo in a wider supplier and payment setup
Galileo is one source inside the flights module, so the same rules and servicing tools apply to the rest of your content.
Travelport: Galileo and Apollo
Galileo content through your own Travelport agreement, credentials and PCC.
Amadeus, Sabre and flight APIs
Other GDS and flight suppliers can feed the same search, checkout and servicing queues.
Payment gateways
Checkout security and reconciliation planned together with the Galileo booking flow.
Flight suppliers you can connect:
Seeru
Amadeus
Duffel
Google Flights
Kayak
Kiwi
Mystifly
PKfare
Sabre
TBO Holidays
Travelport
Back office
Operate Galileo bookings from one admin
The controls supervisors, operations and finance need once Galileo bookings start coming in.
Markups and commissions
By route, airline, cabin, agent or channel, for B2B and B2C sales.
Roles and permissions
Least-privilege access per market, branch and role, kept apart across environments.
Queues and task routing
Routine work runs under policy while senior agents pick up the exceptions.
Event log
Who changed what, when and why, kept as evidence for disputes and supplier audits.
Invoices and settlement
Invoices, ledgers and settlement exports for agents, branches and finance.
Monitoring and alerts
Timeouts, error spikes and pricing mismatches flagged to the team that owns them.
Compare
One-off Galileo integration vs PHPTRAVELS
A quick custom connection can get bookings flowing. Governance, servicing and scale are what decide how it holds up later.
| Area | One-off custom integration | PHPTRAVELS |
|---|---|---|
| Incidents | One-off custom integrationTypically depends on the engineer who built it | PHPTRAVELSLogs, alerts and runbooks with named owners |
| Audit trail | One-off custom integrationOften partial logs | PHPTRAVELSEvent log for bookings, changes, approvals and refunds |
| Brands and markets | One-off custom integrationUsually rebuilt for each brand | PHPTRAVELSCentral rules with local markups and settings |
| Data correctness | One-off custom integrationSome validation, varies by project | PHPTRAVELSValidation gates, drift detection and safe retries |
| Servicing | One-off custom integrationChanges and refunds handled by hand | PHPTRAVELSStandard change, refund and reissue paths with approvals |
| Ownership | One-off custom integrationDepends on the contract with the developer | PHPTRAVELSFull source code under a commercial licence, self-hosted |
Use cases
Who runs Galileo workflows on PHPTRAVELS
B2B distribution
Agent portals, consolidators and partner networks with branch pricing, credit limits and role-based servicing.
B2C online sales
Consumer checkout with live availability, fraud checks and self-service changes where fare rules allow.
Multi-brand operations
Several markets and domains under one central policy, with local overrides and change control.
Why PHPTRAVELS
Galileo workflows you own and control
Source code included
Self-hosted under a commercial licence, so your developers can extend each workflow.
Your own Travelport access
Bookings run on your Galileo PCC and agreement. We build compatible integrations and do not claim a Travelport partnership.
Separate environments
Pre-production and production kept apart, with staged releases and rollback.
Traceable by default
Bookings, approvals and refunds logged with user and time from the first release.
FAQ
Galileo software questions
What platform owners ask before putting Galileo bookings online.
Talk to salesGalileo is a global distribution system owned by Travelport, with the host code 1G. Galileo software usually means the tools used to work with it: the agent desktop for trained staff, or a booking engine connected through the Travelport API that searches, prices, books, tickets and services itineraries with a record of every change.
Access comes from Travelport or an authorised Travelport distributor in your market, under an agreement that sets your PCC, content and credentials. Once that is in place, we connect your PHPTRAVELS platform with those credentials and set up roles for agents, branches and brands.
The agent desktop is supplied by your Travelport provider; avoid unofficial downloads. An API-based integration is installed on your own server instead, with pre-production and production separated, credentials stored securely and a test plan for booking, ticketing and servicing before going live.
Yes, within rules you set. Tickets can be issued automatically once price and fare rules are confirmed, while voids, refunds and high-risk bookings wait for a supervisor's approval. Every step is logged.
Train by lifecycle: search and price, fare rules, PNR creation, ticketing, changes, refunds and queue handling. Pair it with practice in pre-production and checklists, so every agent follows the same process.
Travelport fees depend on your agreement, market and transaction volume. PHPTRAVELS is a one-time licence, shown on the pricing page; integration work is scoped to the Galileo transactions and servicing flows you need.
Keep exploring