SETTINGS
In this article...
Ask a coding agent to build a flight search app against travel APIs, and it will produce something that looks right. It will import an HTTP client, write a search function, map the response into a results list, and hand you a clean React component.
Then you look closer. It selects an authentication mechanism that our gateway doesn't use, and calls endpoints our platform doesn't expose. The code is fine. The assumptions behind it aren't.
That gap is what the Amadeus Travel Builder Plugin is meant to fill: not just our API documentation, but the practices and domain knowledge that make those APIs work well together.
This is the developer toolkit we announced in September as part of our collaboration with Anthropic, and it’s available now in the Claude Code marketplace as a limited beta.
The plugin is a package of travel knowledge installed directly into your agent’s working context, delivered as a set of skills that teach it how to build travel applications:
Installation takes a minute. In Claude Code, search the plugin marketplace for Amadeus Travel Builder and click install, or follow the steps in the GitHub README.
From that point on, when you ask your agent to build something travel-shaped, it generates code aligned with our recommended patterns rather than with whatever it absorbed during pretraining.
The source is public at AmadeusITGroup/amadeus-travel-toolkit. Browse it before you install, and open issues there.
Large language models are strong at generating code. However, the gap isn’t in their coding ability. It's elsewhere: LLMs don't know how our platform works today, and they don't have the domain know-how that the variety of travel use cases demands.
To find out how big that gap is, we conducted a test by running the same prompts with and without the plugin. Without it, four patterns stood out every time:
Wrong authentication, consistently. The agent built an OAuth2 client-credentials flow: an invented client ID and secret, a Bearer token, a call to a token endpoint. That was the pattern for an older generation of travel APIs, and it’s all over the model’s training data. Our platform doesn’t work that way: applications authenticate through a gateway with a single X-API-Key header.
Real endpoints, but the wrong ones. The agent wasn't hallucinating random URLs. It confidently used endpoints that no longer exist, instead of the flight search and activity search APIs the toolkit is built on.
Missing details. Even when the overall structure looked right, specific parameters dropped out: the flow parameter and exact dates on multi-city search, price and traveler filters on activities, and the deep link on flight results. That last field is what makes the booking handoff possible.
Invented code. For Antibes, a town with no airport of its own, the agent generated a complete OAuth helper module, claiming to match the style of an existing file in the project. That file doesn't exist. One wrong assumption became a whole fabricated file.
With the plugin, the same prompts produced different code. The generated application authenticated with the gateway's single API-Key header, called the flight search and activity search APIs directly, and carried the deep link from each result through to the booking button. For Antibes, it resolved the town through city search and found the airports around it from its coordinates, instead of inventing the module. Nothing about the model changed. What changed is what it knew.
The model was never short of coding skill. What it lacked was context and industry know-how, and without them, it fills every blank with a confident guess.
Handing the agent our documentation would help, but documentation says what an API accepts, not how to use it well. The plugin supplies the missing layer through best practices, recommended patterns, and what an experienced integrator would do with them.
The first challenge was teaching agents how our APIs work. The next was deciding how much travel logic the generated application should contain.
The tempting answer is a lot since modern agents will happily write for you their own ranking functions. However, the right answer is close to none.
Search, shopping, ranking, availability, and location management already exist inside Amadeus services, where dedicated teams continuously refine them. Reimplementing that logic in generated code would create a weaker copy that diverges further over time.
So, the applications built with the plugin call Amadeus’ services rather than reimplementing them. The plugin’s contribution is at build time only: It shapes the code the agent writes but never calls our APIs itself. Once built, the application runs on its own, talking to Amadeus services through the API Gateway.
That boundary matters more than it first appears. The Gateway handles authentication, authorization, monitoring, and governance, which means security enforcement stays inside trusted platform components and never inside AI-generated code. The faster agents write code, the more that matters.
The diagram below shows how these pieces fit together, from build time to runtime:

The initial scope is deliberately narrow and available as a free package with usage limitations. It has been designed to minimize development friction and allow people to quickly test an idea based on production-quality data before committing it further, as it provides:
One point on the list above matters more than the others: deep links mean the plugin helps you build shopping and discovery experiences, not booking flows. When a traveler picks a flight or an activity in an app you’ve built, they’re handed off to the provider’s own site to complete the purchase.
It also demonstrates how packaged expertise makes agents better at travel, without putting AI-generated code anywhere near a transaction.
The video below walks you through the entire journey, from discovering and installing the plugin to building a simple travel search application, running it locally, and continuing to a provider’s site to complete a booking.
The beta is open to developers, digital builders, and anyone looking to quickly create a travel app. Access is limited during this phase while we validate the operational framework, learn from real usage, and fold security, legal, and onboarding requirements into the design.
To take part:
Once all beta seats are taken, you can still register your interest and consent to be contacted by Amadeus when the next phase of the project begins.
You can ask questions, report issues, and suggest improvements through the GitHub repository.
Please note that Claude Code offers the most polished experience today, but the solution is designed to work with any agent environment.
The plugin started as an experiment to make it easier for AI assistants to build travel applications on top of our APIs. We increasingly see it as something larger: A foundation for travel-aware agents that can help build multi-service travel experiences with minimal manual effort. The beta will show us how much we got right, and your feedback will help shape what we build next.
Ultimately, one principle has guided the work from the start, and it is the central idea behind the plugin: AI should accelerate travel application development, not reimplement travel systems. Join our journey!
TO TOP
TO TOP