In the tours & activities space, APIs are the backbone of how supply gets distributed. Which means that, sooner or later, every travel distributor ends up building its own connectivity layer.
Some choose to do it internally. Others rely on external solutions. Both paths exist in the market.
What is less often discussed is the real cost structure behind building and operating those integrations over time.
The Visible Costs of API Integrations
When teams evaluate a new API integration, the focus is usually on a few well-defined phases.
What is often overlooked is that each of these phases actually involves dozens of small tasks, iterations and dependencies.
1. Development
This is not just “building the integration”.
It includes:
- Understanding and interpreting API documentation (often incomplete or inconsistent)
- Mapping data models to your own system
- Finding functionality gaps and remove blockers
- Adapting existing architecture and previous integrations
- Handling edge cases, errors and exceptions
- Building, testing and validating end-to-end flows
In practice, this is a sequence of iterations, not a linear process.
2. Supplier Relationship
Beyond technical work, each integration requires continuous coordination with the provider:
- Getting access to documentation and sandbox
- Managing questions, clarifications and inconsistencies
- Assessing the quality and completeness of testing data
- Iterating based on feedback during certification
This is operational work that sits between product, tech and external teams.
3. Certification & Go-Live
Reaching production is not a single step:
- Passing formal certification processes
- Re-testing in production (sandbox data is often limited or unrealistic)
- Fixing real-world issues post-launch
And importantly: Performance in production depends heavily on efficient design, coding quality, caching strategies and architectural decisions
4. Cloud & Infrastructure
This is also part of the visible cost, though often underestimated.
Each integration adds:
- Processing load
- Storage
- Multiple environments (sandbox + production)
And in production, costs are not only volume-driven, they depend on how efficient your architecture is.
These are expected costs. They go into planning, budgeting, and timelines.
The Overlooked Costs
What is less visible at the beginning is what happens after integrations are live.
This is where APIs become ongoing operational systems.
1. Maintenance & Evolution
APIs change continuously: new versions, deprecated endpoints, and functional updates required by suppliers.
Let’s share some real data : based on our experience at Globick managing multiple integrations, this translates into an average of ~24 maintenance tasks per API, per year, and each of these tasks requires analysis, development, testing and deployment.
This is how that average looks in practice:
- For restech A, we handled 38 maintenance tasks over 2 years
- For restech B, 88 tasks over 3 years
- For restech C, 126 tasks over 4 years
- And for restech D, 64 tasks over 4 years
Different providers, same pattern: a continuous stream of work that doesn’t stop after go-live.
2. Monitoring & Control
APIs don’t fail loudly. They fail silently: availability mismatches, pricing inconsistencies, booking errors… Maintaining reliability requires continuous monitoring, debugging, fixing…
This is ongoing operational overhead.
3. Opportunity cost
Every hour spent building and maintaining integrations internally is an hour not invested in product, growth or commercial capabilities. This is rarely modeled but it’s one of the most relevant costs at scale.
4. The Cost of Getting It Wrong
There is another cost that is rarely quantified, but often far more impactful: the cost of a poorly built integration. APIs don’t just fail technically—they fail commercially. Inefficient caching strategies, slow response times or inconsistent availability can directly impact conversion rates. Even a small drop, such as a 2% decrease in conversion due to latency or inaccurate data, can translate into significant revenue loss at scale. Unlike infrastructure or development costs, this impact is not always visible in dashboards, but it accumulates silently over time. In many cases, the revenue lost due to suboptimal integrations can outweigh the cost of building them properly in the first place.
What Does This Actually Cost?
Let’s translate this into a simple, realistic scenario.
Where the numbers come from
We assume a company that already has a platform in place to manage integrations and a minimum experienced team composed of 1 developer and 1 product / key account profile, 2 people dedicated full time to the job. For this exercise, we’ll use a €60K as the total company cost per person per year, taking Spain as a reference point — a reasonable midpoint between higher-cost markets (such as the US) and lower-cost ones (such as eastern Europe).
We also assume the company plans to implement full-featured integrations.
For each API integration, we assume the following effort distribution:
Effort per API
| Component | Effort Description |
| Development | ~6 weeks + 20% additional time (inefficiencies and project management) |
| Supplier coordination & sandbox certification | ~30% of development time |
| Production go-live & certification | ~20% of development time |
| Maintenance & evolution | ~96 hours/year per API (24 tasks × 4h per task on average) |
| Monitoring & control | ~10% of annual development cost |
| Cloud & infrastructure | ~€400 per API/month (including sandbox + production environments) |
Cost per API
| Cost Component | Year 1 (rounded €) | Recurring ( rounded € / year) |
| Development | 10K€ | — |
| Supplier coordination & sandbox certification | 3K€ | — |
| Production go-live & certification | 2K€ | — |
| Maintenance & evolution
(for a single API) |
14K€ | 14K€ |
| Monitoring & control | 1K€ | 1K€ |
| Cloud & infrastructure | 5K€ | 5K€ |
| Total per API | 35K€ | 20K€ |
What This Looks Like at Scale
Once you scale this model, the numbers add up quickly.
A company managing 25 API integrations over a 5-year period is looking at a total cost of over 2,8M€
With 10 integrations, that still means around 1,2M€ over the same period.
Even with just 5 integrations, the total cost is already close to 600K€.
This is not an edge case.
This is what happens when API integrations become part of your core operations.
What Does This Mean in Time?
If we translate these costs into time, the distinction between building and running integrations becomes clear. For the initial phase, a single API integration typically takes around 8 to 10 weeks end-to-end when combining development, supplier coordination and go-live. For a team handling multiple integrations sequentially, this means roughly 1.5 to 2 integrations per quarter. At scale, building 10 integrations would take close to a full year of continuous work for a small dedicated team, while 25 integrations could extend to 2+ years. Once live, the dynamic changes completely: maintenance becomes an ongoing operational load. Each API requires around 12 working days per year (~96 hours), meaning that 10 integrations already consume 4–5 months of work annually, and 25 integrations require the equivalent of more than a full-time person dedicated exclusively to maintenance. In other words, building integrations is a finite effort—but running them is a permanent one.
“Will Standards and AI development Solve This?”
Partially.
Standards like OCTO or tools like Claude Code or other agentic developments can improve efficiency, especially in the early stages.
From all the chapters laid out before, development and maintenance would be the most benefited from standardization and/or agentic development.
Let’s assume:
- ~50% reduction in development effort
- ~25% reduction in maintenance effort
The overall impact is meaningful, but limited.
Across the full cost structure, this typically translates into ~15–20% total cost reduction.
Why?
Because a large part of the cost does not disappear:
- Monitoring
- Infrastructure
- Supplier-driven changes
- Impact assessment to the current platform
- Ongoing operational work
- and many others
In other words: Standardization and AI can improve how integrations are built, but they don’t fundamentally change the cost of running them over time
Final Thought
APIs are not a one-time project. They are an operational system that grows with your business.
And as the number of integrations increases:
- Complexity compounds
- Costs become structural
- Speed slows down
The real cost is not in building the first integrations. It’s in running them at scale.