Roaming is one of those telecom miracles that still feels a bit like a 1999 business process that refuses to die.

It works. Mostly.

But the “logic” behind roaming was designed for a world where:

• The operator is the product owner
• The SIM is the control point
• The customer experience is an afterthought
• Settlement happens later, when nobody remembers what the user actually did

That legacy logic is why roaming still feels opaque. Why billing surprises still happen. Why “why was I charged” turns into a ticket, then an escalation, then a spreadsheet, then a shrug.

And it is exactly why APIs are taking over.

Not because roaming is broken. Because roaming’s control model is outdated.

The old roaming stack is a chain of handoffs

Traditional roaming is built on agreements and interconnect plumbing: visited network access, authentication, policy, charging, and then settlement.

It is a system optimized for carrier-to-carrier relationships, not for real-time product decisions. For example:

• “Can I know right now if this device is roaming?” In legacy roaming logic, that is not a developer-friendly question.
• “Can I apply a specific quality policy for this user session?” Legacy roaming is not built for that kind of on-demand control.
• “Can I verify a number, reduce fraud, or confirm location for a transaction?” Historically, these sit outside “roaming” as the customer thinks of it.

Now compare that with what digital services expect in 2026:

• programmatic decisions
• real-time signals
• consistent interfaces across networks
• auditability and policy control

That gap is where network APIs walk in.

APIs are not “nice to have,” they are control points

Here’s the important shift: APIs are not just a new developer channel. They are a new control layer.

GSMA Open Gateway is basically the industry admitting that the best way to scale telecom value into digital services is through standardized network APIs. It’s a framework for exposing network capabilities through common interfaces, with API definitions aligned through the CAMARA project.

So instead of building a product around roaming quirks, developers can build around network capabilities:

• device status
• number verification
• SIM swap checks
• quality on demand
• location verification
• edge discovery

These are not theoretical. They are formalized as part of Open Gateway’s API catalog and FAQ materials.

And once those capabilities become APIs, the roaming experience stops being “whatever the visited network does” and starts becoming something a product can orchestrate.

That is the control-layer narrative in one sentence.

Roaming status becomes a simple API call

Let’s get concrete.

CAMARA defines a “Device Roaming Status” API that lets an application check whether a device is roaming. There are also subscription-based variants that push events when a device enters or exits roaming.

This matters more than it sounds.

Because once you can reliably detect roaming in real time, you can do product logic that legacy roaming never supported cleanly:

• trigger travel data bundles at the right moment
• enforce enterprise policies (allowed countries, allowed networks)
• apply risk controls (roaming + high-risk transaction patterns)
• Notify finance teams before the bill becomes a surprise

Telefónica, for example, publicly documents a Device Roaming Status API under its Open Gateway program, framing it as a way to better control resource management during international roaming.

This is roaming logic moving from the back office to the runtime.

The NEF shift: from telecom core to programmable network

Under the hood, a lot of this is enabled by capability exposure in 5G cores.

3GPP has been pushing the idea that networks should expose capabilities through APIs, including via the Network Exposure Function (NEF). 3GPP’s own explainer pages make the point clearly: exposure APIs let applications leverage and influence network capabilities instead of passively accepting whatever the network provides.

If you want a more formal technical anchor, ETSI publications for NEF-related specs describe NEF as part of the 5G service-based architecture that provides exposure services to consumers.

You do not need to memorize NEF interfaces to understand what is happening.

Telecom is turning itself into a programmable environment, and the API becomes the product boundary.

Why is this happening now

Three forces are colliding.

Platform expectations

Every digital product team now thinks in APIs. They want to integrate capabilities, not negotiate telecom complexity. Open Gateway explicitly targets this gap by creating a consistent developer-facing approach across operators.

Monetization pressure

Operators have been stuck selling connectivity as a commodity while digital platforms capture the value. Network APIs are a way to monetize differentiated capabilities, not just megabytes. TM Forum has been deeply involved in the “standardized API monetization” narrative through its work with CAMARA and Open Gateway-aligned initiatives.

Enterprise control demand

Enterprises do not want “a roaming plan.” They want visibility, policy, and control, ideally in a dashboard with automation.

APIs are the only scalable way to deliver that. A community discussion in TM Forum circles even frames “real-time blocking and unblocking” and operational actions as best served via open APIs exposed by MNOs or MVNEs.

That is the market telling you the same thing: control layers win.

What replaces roaming logic in practice

This is where people get confused, so let’s say it cleanly.

APIs are not replacing roaming agreements. They are replacing “roaming logic” as the product brain.

Roaming still exists underneath. But the decision-making moves up the stack.

Instead of:

• roaming behavior determined by carrier defaults
• user experience shaped by delayed charging and policy quirks

You get:

• real-time network signals exposed to apps
• policy-based orchestration across providers and geographies
• the ability to treat connectivity like a controllable system

The new roaming brain looks like this

• a control layer (enterprise orchestration, travel connectivity platforms, MVNE/MVNO operations)
• API access to network capabilities (Open Gateway and operator developer portals)
• automation rules (who can roam, where, how much, what quality)
• audit trails (what happened, when, and why)

Orange, for example, positions “Network APIs” as a way to integrate advanced network functionality without developers needing deep telecom knowledge, explicitly referencing alignment with GSMA Open Gateway and CAMARA.

That is the direction of travel: abstract the network, expose controls, let software do the rest.

What this means for travel eSIM brands

Here is the spicy part for the travel eSIM market.

A lot of travel eSIM brands compete on:

• UX
• pricing psychology
• packaging
• branding

But as network APIs mature, the differentiation shifts toward:

• Who has better control logic
• Who can react in real time
• Who can prove performance and enforce policies
• Who can integrate into platforms (airlines, OTAs, fintech, enterprise tools)

In other words, the winners are not just selling data. They are selling orchestration.

This is also why you will see more “embedded connectivity” partnerships. Because APIs make it easier for non-telco brands to consume network capabilities, while the control layer handles complexity.

Conclusion: Roaming is becoming a software problem, and software always picks APIs

If you look at this trend next to other parts of the market, it rhymes.

Payments moved from bank rails to developer platforms. Cloud moved from hardware procurement to APIs. Identity moved from on-prem directories to programmable layers.

Connectivity is doing the same thing.

GSMA Open Gateway and CAMARA are the clearest signals that the industry is standardizing how networks expose capabilities to developers. And 3GPP’s ongoing focus on exposure frameworks confirms that “programmable network capabilities” is no longer marketing language. It is part of the architecture roadmap.

So no, roaming is not going away.

But the old roaming logic, the slow, opaque, carrier-first control model, is being wrapped, abstracted, and increasingly bypassed at the product layer.

The control layer becomes the real product.
The API becomes the interface to the network.
And the brands that survive will be the ones that can orchestrate connectivity like software, not resell it like a tariff.