MCP for Corporate Travel: The First Native Server for AI-Readable Travel Data
TL;DR. Travel Code has launched the first native Model Context Protocol (MCP) server in corporate travel. Compliant with Anthropic's open MCP specification, it exposes bookings, spend, policy compliance, and duty-of-care status as AI-readable tools and resources. Corporate travel teams can query travel data conversationally through Claude, ChatGPT, or internal LLMs — with per-stakeholder access controls and audit logging built in.
The corporate travel data problem
A managed travel program's data does not live in one place. According to the Global Business Travel Association (GBTA) 2025 Business Travel Buyer Sentiment report, an average employer operates between four and seven distinct systems that each hold a slice of the truth: an online booking tool (OBT), a Global Distribution System (GDS) feed through a Travel Management Company, an expense platform (Concur, Brex, Ramp), a duty-of-care provider (International SOS, Crisis24), a corporate card issuer, an HR system for traveler profiles, and often a separate GL/ERP for reconciliation.
Static dashboards were designed to answer a fixed set of questions against this landscape — top routes, ticket-class mix, hotel spend by market. They cannot answer correlated questions across three or more of those systems on demand: "what did sales spend flying to our top-ARR accounts last quarter, and which of those trips fell outside policy?" That question requires joining CRM data to booking data to policy data — the classic BI ticket that takes two to four weeks per GBTA's 2024 Data Maturity survey.
Large language model workflows want that correlation now, in a conversation, without an ETL job. That is what the Model Context Protocol was built for — and why we shipped a native MCP server as part of Travel Code's Bring Your Own Data (BYOD) platform.
What MCP is (in plain terms)
The Model Context Protocol (MCP) is an open standard, published by Anthropic in November 2024 and maintained at modelcontextprotocol.io, that defines how large language models discover and interact with external data sources and tools. An MCP server exposes three primitive types: resources (read-only data endpoints identified by URI), tools (parameterized functions the LLM can invoke), and prompts (reusable instruction templates). Clients — including Claude Desktop, Claude Code, and third-party integrations for ChatGPT and custom applications — connect over standard I/O or Server-Sent Events (SSE), negotiate capabilities via JSON-RPC 2.0, and execute typed calls. The specification is language-agnostic; reference SDKs exist in TypeScript, Python, Java, and C#. MCP is to LLM data access what the Language Server Protocol became for code editors: a single interface any client can implement, and any data source can serve. Drawing from 8+ years building AI-powered corporate travel platforms, the patterns that hold up under production load are exactly these kinds of thin, typed, capability-negotiated protocols — not bespoke plugins per vendor.
Why corporate travel is a strong MCP use case
Corporate travel data lives in four to seven distinct systems per employer (GBTA 2025 BTI Outlook). Static dashboards cannot answer questions that require correlation across three or more of these — "what did we spend on unmanaged sales travel to top-ARR accounts last quarter, and which trips fell outside policy?" — because dashboards are built for a fixed report shape. LLMs with MCP tool access can traverse these systems in a single conversation, decomposing the question into typed calls and joining the results in context. The sensitive-data profile of corporate travel (PII, PNRs, spend, itineraries, health-affecting duty-of-care flags) also fits MCP's security model: authentication, scoping, and audit logging happen server-side, not in the model. A finance director connects and only sees spend rollups; a security operator connects and only sees traveler locations. Same server, different scope. That combination — high-dimensionality data, high-diversity stakeholders, high-sensitivity records — is precisely the profile MCP was designed to serve.
What Travel Code's MCP server exposes
Version 1.0 exposes seven read-only tools, three write tools (gated by role), and a small resource set. All types are declared in a JSON Schema returned from tools/list so the client-side LLM can validate arguments before invocation.
- list_trips — filter by traveler, date range, cost center, policy status, sustainability tag.
- get_trip — full PNR, segments, cost breakdown, carbon estimate for a single trip ID.
- spend_summary — aggregated spend by dimension (traveler, department, route, supplier, class).
- policy_check — evaluate a proposed itinerary against the active travel policy; returns violations and pre-trip approval requirements.
- duty_of_care_status — traveler locations with active risk overlays, sourced through the customer's configured provider.
- rate_reshop_history — every re-shop attempt RateGuard has made against a booking and the savings validated.
- traveler_profile — loyalty numbers, preferences, and passport expirations (scoped by role).
- request_pre_approval (write) — submit a trip request for approval routing.
- notify_traveler (write) — send a policy nudge or safety alert through the configured channel.
- update_cost_center (write) — reclassify a trip's cost center for GL reconciliation.
Resources include travelcode://policy/current, travelcode://carbon-methodology, and travelcode://schema/openapi.json — an OpenAPI mirror of every tool for clients that want a REST view. Detailed field-level schemas are published in the server's tools/list response and mirrored at mcp.travel-code.com.
Connecting to Claude Code in 3 commands
The fastest path — Claude Code has native MCP support:
export TRAVELCODE_MCP_TOKEN="tc_live_..." # from Settings → Developer → MCP Tokens
claude mcp add travelcode \
--transport http \
--url https://mcp.travel-code.com \
--header "Authorization: Bearer $TRAVELCODE_MCP_TOKEN"
claude # session auto-connects; try: "Show me last quarter's top 10 routes by spend"
Connecting to a ChatGPT custom GPT
ChatGPT does not yet speak MCP natively, so the server also publishes an OpenAPI mirror. Import it as a custom GPT Action:
# In ChatGPT → Create a GPT → Configure → Actions → Import from URL:
schema_url: https://mcp.travel-code.com/openapi.json
auth:
type: bearer
token: ${TRAVELCODE_MCP_TOKEN} # paste from Travel Code Settings
# Same tools, same scopes, same audit trail as the MCP transport.
Connecting to an internal or on-prem LLM
For data-sovereignty deployments — where the LLM runs inside a customer's VPC — use the official Python MCP SDK against the same endpoint:
import asyncio, os
from mcp import ClientSession
from mcp.client.sse import sse_client
TOKEN = os.environ["TRAVELCODE_MCP_TOKEN"]
URL = "https://mcp.travel-code.com/sse"
async def main():
async with sse_client(URL, headers={"Authorization": f"Bearer {TOKEN}"}) as (r, w):
async with ClientSession(r, w) as session:
await session.initialize()
tools = await session.list_tools()
print([t.name for t in tools.tools])
result = await session.call_tool(
"spend_summary",
{"group_by": "cost_center", "date_range": "last_quarter"},
)
print(result.content)
asyncio.run(main())
The same SDK is used by internal orchestrators built on LangChain, LlamaIndex, and Semantic Kernel. See our AI agents page for the full deployment reference.
Cross-system correlation in action
Cross-MCP correlation is the capability MCP unlocks that dashboards cannot. Consider the query "show sales travel cost versus ARR for our top 50 accounts last quarter." Executed against Travel Code's MCP server alongside a Salesforce MCP server, an LLM decomposes it into three tool calls: salesforce.query_accounts(sort='arr', limit=50) returns account IDs and ARR; travelcode.list_trips(account_ids=[...], date_range='last_quarter', category='sales') returns matched trips with total spend, ticket class, and traveler roles; a final in-context join produces the correlation. Response times in production average 1.8 seconds for a 50-account query (measured July 2026 on Travel Code's production MCP endpoint, p95 4.2s). The equivalent report in a static BI stack requires a data-engineering ticket, a scheduled ETL job, and a two-to-four-week turnaround per GBTA's 2024 Data Maturity survey. MCP collapses that to a conversation — and every call, every scope check, and every returned row is captured in the audit log.
Security and access control
MCP puts sensitive data in front of an LLM by design, so the security posture matters more than the protocol itself. Travel Code's server enforces four layers, each independently verifiable in the audit stream:
- Bearer tokens with per-stakeholder scopes. Tokens are minted with role bundles — finance-readonly, ops-writeback, security-doc-only, developer-sandbox — that map to a fixed subset of tools and resource URIs. A finance token literally cannot invoke
duty_of_care_status; the server returns a JSON-RPC method-not-permitted error before any data leaves the tenancy boundary. - Row-level scoping. Every tool call is filtered against the caller's cost-center allow-list resolved at token issuance. A regional controller sees their region only, even when the model asks for "all trips."
- Full audit log. Each JSON-RPC request/response pair is written to a tamper-evident log, exportable to the customer's SIEM. This is the artifact SOC 2 and ISO 27001 auditors ask for; it is also the artifact GDPR Article 30 requires.
- Token revocation & short TTLs. Tokens default to a 30-day TTL and can be revoked instantly from Settings → Developer. A revoked token fails the next JSON-RPC handshake without ever hitting a tool.
The full security architecture — including how MCP scopes compose with the wider Travel Code role model — is documented alongside our duty of care hub and our duty of care system architecture reference.
Static dashboards vs. MCP-enabled queries
| Dimension | Static BI dashboard | MCP-enabled query |
|---|---|---|
| Question shape | Fixed at build time | Arbitrary, decomposed by the LLM at request time |
| Cross-system joins | Requires ETL pipeline | Native — client orchestrates multiple MCP servers |
| Turnaround for a new report | 2–4 weeks (GBTA 2024) | Seconds to minutes |
| Access control | Row-level security, often ad hoc | Server-enforced scopes per token |
| Auditability | Query logs (if enabled) | Full JSON-RPC request/response log |
| Consumer | Human via UI | Human via LLM, plus agents/automations |
| Data freshness | Cadence of ETL (nightly typical) | Live — reads production APIs directly |
| Setup cost per net-new question | Data-eng ticket | Zero — same tools, new prompt |
What's next: roadmap and early access
Version 1.0 ships today. Three items are on the near-term roadmap:
- Standards contributions. We are working with the MCP maintainers on a proposed travel-domain resource schema — a shared vocabulary for trip, itinerary, and duty-of-care objects that other TMCs, GDSs, and expense platforms can adopt. Details will land at modelcontextprotocol.io.
- v2 write surface. Booking-flow tools (search fares, hold a PNR, ticket) are in private beta and will move to GA once the human-in-the-loop confirmation patterns settle across major LLM clients.
- Prompt library. A curated set of MCP prompts for common travel-manager workflows — quarterly business reviews, off-policy exception reports, duty-of-care briefings — will ship alongside v1.1.
Early access is open to any Travel Code customer on the BYOD plan. If you want to see it against your own data, request an MCP token from the Developer panel or reach us through our Bring Your Own Data page. For the broader BYOD narrative — how MCP fits alongside RateGuard, real-time duty of care, and unified analytics without a TMC migration — start with the same hub.
Frequently Asked Questions
What is MCP and who created it?
MCP is the Model Context Protocol, an open standard published by Anthropic in November 2024. It defines how LLM clients (Claude, ChatGPT via bridges, custom applications) discover and invoke tools, read resources, and use prompt templates exposed by an MCP server. The spec, reference implementations, and SDKs are maintained at modelcontextprotocol.io under a permissive open-source license.
Is Travel Code the first corporate travel platform with an MCP server?
Yes. As of publication (August 2026), Travel Code is the first native MCP server in corporate travel. We surveyed the top 20 TMCs and expense platforms by GBTA-reported market share; none publish an MCP server, and no third-party bridge covers the full trip/spend/duty-of-care surface. We will update this claim if that changes.
Does the MCP server require me to migrate off my current TMC?
No. Travel Code is a Bring Your Own Data overlay — it runs alongside any TMC (Concur, Navan, TravelPerk, BCD, CWT, Egencia) and ingests your existing booking, expense, and duty-of-care feeds. The MCP server exposes the unified view. There is no rip-and-replace and no re-contracting with your TMC.
How is authentication handled?
Bearer tokens issued from the Travel Code Developer panel, scoped to a role bundle (finance-readonly, ops-writeback, security-doc-only, developer-sandbox) and a cost-center allow-list. Tokens default to a 30-day TTL and can be revoked instantly. All calls are audit-logged and exportable to the customer's SIEM.
What LLM clients does the server support?
Anything that speaks MCP over stdio or SSE (Claude Desktop, Claude Code, Continue, Zed, custom Python/TypeScript agents built on the official SDKs) works natively. ChatGPT custom GPTs and other REST-only clients use the OpenAPI mirror at travelcode://schema/openapi.json. Internal on-prem LLMs (Llama, Mistral, private OpenAI deployments) connect via LangChain, LlamaIndex, or Semantic Kernel's MCP adapters.
Can I self-host the MCP server?
Not in v1.0. The server runs in Travel Code's SOC 2 Type II environment and reads directly from the production data plane. Self-host is on the roadmap for customers on the on-prem/VPC deployment plan; contact us if that is a hard requirement.
Is there a cost for the MCP server?
No incremental license fee for Travel Code BYOD customers. RateGuard (our continuous rate re-shopping engine, priced at 25% of validated savings) and other Travel Code products are billed on their own terms and are unaffected by MCP usage. See pricing for full plan detail.
Sources
- Anthropic — Model Context Protocol specification and SDKs. modelcontextprotocol.io
- GBTA — 2025 Business Travel Buyer Sentiment Report (BTI Outlook). gbta.org
- GBTA — 2024 Travel Program Data Maturity Survey.
- Travel Code — Production MCP server telemetry, July 2026 (internal, available to customers under NDA).
