TL;DR — Mobile Number Portability (MNP) lets a subscriber keep their number when switching carriers. The number (MSISDN) stays fixed, but the IMSI, carrier-of-record, and MCC/MNC pair change on the destination network. SMS senders that route on the number prefix instead of the live Home Location Register (HLR) send OTPs to the old carrier — and 8-12% fail silently, worse in the UK (9-11%) and India (12-18%). The developer fix is HLR-before-send with Twilio Lookup v2 or Telesign Phone ID. The structural fix is real-SIM termination: a real carrier SIM has a fixed MCC/MNC and no porting history, so all four MNP failure modes vanish. VirtualSMS runs real carrier SIMs across 145+ countries and 2500+ services with a consistently high SMS-arrival rate and a 20-minute auto-refund.
If you send SMS one-time passwords at any scale, a slice of them are failing for a reason that never shows up cleanly in your logs. The user submits a valid mobile number, your aggregator reports the message as delivered, and the code never arrives. The most common invisible cause is Mobile Number Portability — the number was ported to a new carrier, and the OTP was routed to the old one.
This guide explains the mechanism end to end: what MNP changes underneath a phone number, why it breaks 8-12% of aggregator-routed verifications, how the failure rate varies by country, the developer detection code that fixes it, and why real carrier-issued SIM cards sidestep the whole problem.
Key Takeaways
- MNP keeps the MSISDN fixed but changes the IMSI, carrier-of-record, and the MCC/MNC pair returned by a live HLR query
- Routing on the number prefix instead of the live HLR silently fails 8-12% of OTPs on aggregator-routed traffic
- The failure rate scales with porting utilisation: UK 9-11%, India 12-18%, Germany 1-2%
- The developer fix is HLR-before-send via Twilio Lookup v2 or Telesign Phone ID — a few cents per query
- Real carrier-issued SIM termination removes all four MNP failure modes structurally, hitting a consistently high SMS-arrival rate
What Is Mobile Number Portability?
Mobile Number Portability (MNP) is the regulatory mechanism that lets a subscriber keep the same phone number when switching mobile carriers. The user-facing number — the MSISDN, the +44 7700 90xx xxx string — never changes. Everything underneath it does: the IMSI (International Mobile Subscriber Identity) tied to the new SIM, the carrier-of-record in the national porting registry, the Mobile Country Code (MCC), and the Mobile Network Code (MNC) returned by a live Home Location Register query. From the subscriber’s perspective, MNP is invisible. From a sender’s perspective, it is the single largest reason SMS routing goes wrong silently.
Every developed market regulates MNP under a national framework. In the United States, the Federal Communications Commission (FCC) wrote Local Number Portability (LNP) into the Telecommunications Act of 1996 and codified the rules under 47 CFR Part 52, with the Number Portability Database (NPDB) operated by iconectiv under FCC oversight. The European Union folded MNP into the Electronic Communications Code (Directive 2018/1972) and delegated administration to national regulators — Ofcom in the UK, Bundesnetzagentur in Germany, Arcep in France, ACM in the Netherlands. India MNP is overseen by the Telecom Regulatory Authority of India (TRAI); Brazil by ANATEL. The registry mechanics differ; the verification implication is identical — query the live record, not the prefix.
The porting deadlines are why this matters at any given moment. FCC LNP rules require simple wireless-to-wireless ports to complete within one business day. Ofcom in the UK mandates same-day porting under the General Conditions of Entitlement. India TRAI moved to a same-day port-out window in 2019. That means a meaningful fraction of the numbers hitting your verification flow right now are inside a 24-hour transition where the registry record is updating and aggregator caches lag behind it.
The foundational comparison: VoIP vs physical SIM verification →Citation Capsule — Mobile Number Portability keeps the MSISDN (E.164 phone number) fixed while changing the IMSI, carrier-of-record, and the MCC/MNC pair on the destination network. It is regulated nationally: FCC LNP with the iconectiv NPDB in the US; the EU Electronic Communications Code administered by Ofcom (UK), Bundesnetzagentur (Germany), Arcep (France), and ACM (Netherlands); TRAI in India; ANATEL in Brazil. Same-day or next-business-day porting deadlines mean a live fraction of numbers are mid-transition at any moment, so the correct verification signal is the live HLR record — never the number prefix.
How Does MNP Change the Number Underneath — HLR, SS7, and the MCC/MNC Pair?
SMS routing depends on a chain of carrier databases, and MNP quietly rewrites one link in it. When an application server hands an OTP to an SMS aggregator, the aggregator has to answer one question: which carrier currently holds this MSISDN? That answer comes from the Home Location Register (HLR) — a per-carrier database mapping a phone number to the IMSI on the SIM, the visiting network if roaming, and the originating carrier. The HLR is queried over Signalling System 7 (SS7) using the MAP (Mobile Application Part) protocol, carried between Signal Transfer Points by the Signalling Connection Control Part (SCCP).
Three values come out of an HLR query that matter for verification:
- MCC (Mobile Country Code) — three digits identifying the country of the SIM. UK is 234, Germany 262, France 208, India 404/405, USA 310-316. Effectively immutable per SIM.
- MNC (Mobile Network Code) — two or three digits identifying the carrier within the country. UK Vodafone is 234-15, UK EE is 234-30, UK O2 is 234-10. The MNC changes when a number is ported. This is the field an SMS sender must read live.
- MSISDN — the E.164 phone number itself. Stable across porting.
Twilio Lookup v2 returns these in the line_type_intelligence payload as mobile_country_code and mobile_network_code. Telesign Phone ID returns equivalent fields plus a portability flag. Numverify and Numlookup wrap the same upstream HLR data in consumer-friendly APIs. National registries hold the authoritative record; commercial APIs cache it with a sync lag from minutes to hours depending on the registry. Indian TRAI MNP even adds a roughly 3-second routing delay versus non-ported numbers, because every porting-eligible message takes an extra MNP-database hop.
The porting indicator is the cleanest cross-source signal. A number whose prefix implies one MNC but whose live HLR returns a different MNC has been ported. A number whose live MCC/MNC matches the prefix mapping has not. Routing logic that ignores this distinction is the source of nearly every silently-failed SMS in aggregator-routed verification.
Citation Capsule — An HLR query over SS7/MAP returns three values relevant to SMS verification: the MCC (country of the SIM, effectively immutable), the MNC (the carrier, which changes when a number is ported), and the MSISDN (the E.164 number, stable across porting). Twilio Lookup v2 exposes the MCC/MNC in its
line_type_intelligencepayload; Telesign Phone ID adds a portability flag. A number is ported when the live MNC differs from the MNC implied by the prefix. Routing on the prefix rather than the live MCC/MNC is the core cause of MNP-driven SMS verification failure.
Why Does MNP Break SMS Verification? Four Compounding Causes
The 8-12% silent-failure rate is not one bug — it is four failure modes stacked on top of each other. Removing any single one cuts the rate by roughly a quarter. Eliminating all four requires controlling the terminating end of the route, which is the structural fix real-SIM termination delivers.
1. Stale routing — the sender uses cached MNP data. Aggregators cache MNP lookups to keep query cost bounded, with cache lifetimes from a few minutes (premium routes) to several days (cost-optimised routes). When a number is ported and the sender hits a stale cache, the SMS routes to the old carrier. That carrier either rejects it (a clean failure you can retry) or accepts it and tries to redirect via SS7 (a dirty failure where the message queues for hours, duplicates, or drops). The dirty path is the worst, because the status callback shows DELIVERED while the handset receives nothing.
2. Carrier reputation flags — ported numbers score lower. Ported numbers correlate with churn, resellers, and short-lifecycle SIMs — all features of A2P fraud patterns. Several destination carriers apply lower trust scores to ported number ranges, and Twilio Lookup surfaces a derived version of this in its risk fields. The practical effect: ported numbers sometimes receive OTPs 30-90 seconds slower, long enough for users to assume the code never arrived and retry, which generates duplicates and worsens the flag.
3. Bulk-list filtering — some operators block ported numbers from international senders. Porting plus an international bulk-sender prefix is a high-confidence fraud pattern, so some mobile network operators throttle or block that combination. The collateral damage is the legitimate verification that happens to terminate on a ported handset. India DLT (Distributed Ledger Technology) registration compounds this: non-registered senders sending OTPs to ported numbers face an extra filtering layer that discards a measurable fraction of messages.
4. HLR cache poisoning — old snapshots, wrong routing. Large senders keep internal HLR caches to amortise lookup cost. When the refresh policy is too lazy, an old MCC/MNC pair keeps routing to the wrong network even after a fresh registry record exists — and every retry hits the same stale entry until the cache is invalidated. Verification flows where the same number fails several times in an hour, then suddenly succeeds, are usually a cache flipping over.
More on the failure modes: why SMS verification gets blocked →How Bad Is the 8-12% Failure Rate — Region by Region?
The headline rate hides a wide regional spread. Markets with low MNP utilisation see almost no MNP-driven failures; markets with high utilisation and complex registries see far more. The table below lists the practical MNP failure rate observed on aggregator-routed SMS in 2026, by market.
| Region | MNP Utilisation | Aggregator-Routed Failure Rate | Notes |
|---|---|---|---|
| United States (FCC LNP, NPDB) | ~7% ported lifetime | 2-4% | Tier-1-to-Tier-1 ports (T-Mobile, Verizon, AT&T) are clean; MVNOs and resellers add noise. iconectiv NPDB is the authoritative cache. |
| United Kingdom (Ofcom MNP) | ~12% ported | 9-11% | EE, Vodafone, O2, Three plus a dense MVNO layer. Same-day porting and high churn drive high MNP-affected traffic. |
| Germany (Bundesnetzagentur) | ~3-4% ported | 1-2% | Low porting culture. Cleanest MNP picture of the major markets. |
| India (TRAI MNP) | ~15-20% ported | 12-18% | Heavy post-2017 port-ins. DLT registration adds an extra filter layer on top of MNP routing. Highest failure rate of any market. |
| Brazil (ANATEL) | ~10-13% ported | 8-12% | Reasonably current registry; aggregator caches are the weak link. |
| France (Arcep) | ~6-8% ported | 3-5% | A post-2012 porting surge has since stabilised. |
| Mexico (IFT) | ~9-12% ported | 7-10% | Same-day porting introduced in 2017 amplified MNP traffic. |
| Netherlands (ACM) | ~8% ported | 3-6% | Clean registry, lighter aggregator-cache lag than the UK. |
Two cross-cutting patterns. First, the failure rate scales roughly linearly with porting utilisation — more porting, more MNP-driven failures. Second, registry quality matters more than regulator strictness: Germany runs a cleaner pipeline than the UK despite both being mature regulators, and that shows in the gap. Aggregator-cache hygiene is downstream of how easy the national registry makes live queries.
Cheapest-per-number is the wrong question. At a $0.008 floor with ~88% effective delivery on MNP-affected UK traffic, the real cost per verified account is closer to $0.009 — before the support cost of the failed activations. A real-SIM activation at $0.05 with consistently high delivery comes out cheaper per verified account once MNP losses are priced in, and dramatically cheaper per retained customer once you count the users who abandon the failed flow.
How Do You Detect MNP-Related Failures? (Developer Section)
For anyone building or operating an SMS verification flow, the single highest-leverage change is HLR-before-send: query the live MCC/MNC pair before committing to an SMS, then route on the result. The query costs a few cents per Twilio Lookup or Telesign Phone ID call; the avoided cost is one failed SMS plus one re-verification per ~10 ported numbers.
Twilio Lookup v2 — Node.js
// Node.js — Twilio Lookup v2 with line_type_intelligence + porting flag
// npm i twilio
import twilio from 'twilio';
const client = twilio(process.env.TWILIO_SID, process.env.TWILIO_TOKEN);
async function mnpAware(phoneE164) {
const r = await client.lookups.v2.phoneNumbers(phoneE164).fetch({
fields: 'line_type_intelligence,sim_swap,call_forwarding',
});
const lti = r.lineTypeIntelligence ?? {};
const mcc = lti.mobile_country_code; // e.g. "234" = United Kingdom
const mnc = lti.mobile_network_code; // e.g. "30" = EE Limited (post-port)
const type = lti.type; // "mobile" | "fixedVoip" | "nonFixedVoip" | "landline"
const carrier = lti.carrier_name;
// Porting indicator — Lookup returns the MCC/MNC of the CURRENT carrier.
// If your registry-of-record disagrees, the number has been ported.
return { mcc, mnc, type, carrier, ported: type === 'mobile' && carrier !== r.callerName };
}Twilio Lookup v2 + Telesign HLR fallback — Python
# Python — Twilio Lookup v2 + Telesign HLR fallback
# pip install twilio requests
import os, requests
from twilio.rest import Client
twilio = Client(os.environ["TWILIO_SID"], os.environ["TWILIO_TOKEN"])
def mnp_check(e164: str) -> dict:
"""Return the post-port routing facts for an E.164 number."""
rec = twilio.lookups.v2.phone_numbers(e164).fetch(fields="line_type_intelligence")
lti = rec.line_type_intelligence or {}
return {
"mcc": lti.get("mobile_country_code"),
"mnc": lti.get("mobile_network_code"),
"type": lti.get("type"),
"carrier": lti.get("carrier_name"),
# Telesign Phone ID fallback — an independent MNP source that cross-checks Twilio.
# Most useful where TRAI MNP cache lag is measurable.
"telesign_block": _telesign(e164),
}
def _telesign(e164: str) -> dict:
r = requests.get(
f"https://rest-api.telesign.com/v1/phoneid/{e164.lstrip('+')}",
auth=(os.environ["TELESIGN_ID"], os.environ["TELESIGN_KEY"]),
timeout=5,
)
return r.json().get("number_deactivated", {})Cross-checking Telesign against Twilio costs more per query but catches edge cases where one cache lags the registry — most often in Indian TRAI MNP traffic. Cross-source HLR data resolves roughly 80% of those conflicts.
The retry policy that uses HLR data
// Auth-flow retry policy for MNP-affected numbers.
// Pattern: HLR before charging the customer; route on the post-port carrier.
async function sendOtp(userPhone) {
const mnp = await mnpAware(userPhone);
// 1. Hard block on non-mobile line types — no point sending.
if (mnp.type !== 'mobile') {
return { ok: false, reason: 'line_type_not_mobile', cost: 0 };
}
// 2. Resolve the destination carrier from MCC/MNC, not from the prefix.
// The prefix (+44 7700 ...) tells you the ORIGINAL carrier; MCC/MNC
// tells you who actually holds the number TODAY.
const route = pickRouteForMncMnc(mnp.mcc, mnp.mnc);
if (!route) {
return { ok: false, reason: 'no_route_for_current_carrier', cost: 0 };
}
// 3. Send via the post-port carrier — the MNP-aware step that
// aggregator-routed SMS skips when it cost-optimises on cached data.
return route.send(userPhone, generateCode());
}The pattern: HLR-before-send drops the message-issued count on non-mobile line types to zero, and for mobile numbers the post-port MCC/MNC drives the route — never the prefix. Step 3 is where most consumer-facing apps stop short, because it means maintaining per-carrier route choices instead of handing the whole send to one aggregator. That operational cost is the practical reason aggregator-routed traffic still loses 8-12% to MNP.
Don’t trust the prefix. A +44 7700 ... UK mobile prefix maps to EE’s original allocation, but the live HLR may return MNC 15 (Vodafone) or MNC 10 (O2) after porting. Sending to EE’s SMSC under the old assumption is the single most common silent failure mode in verification flows.
Why Is Real-SIM Termination MNP-Immune?
VirtualSMS provides SMS verification via real physical SIM cards across 145+ countries and 2500+ services — WhatsApp, Telegram, Instagram, Discord, OpenAI, Coinbase, banking and dating apps, and more. When a customer requests an activation, we allocate a real carrier-issued SIM — a genuine mobile SIM on operators like Vodafone, O2, T-Mobile, and Lebara, not VoIP. The SIM’s IMSI is registered against its carrier, the MCC/MNC pair is fixed, and there is no porting history, because the SIM has never been ported.
That single structural fact removes every one of the four MNP failure modes from the route:
- No stale aggregator cache, because there is no aggregator in the path — the platform sends the OTP to our SIM directly via the destination carrier SMSC, and the SIM receives it on its native network.
- No carrier reputation flag for ported ranges, because the number was never ported.
- No bulk-list filter against a sender prefix, because the sender is talking to a real consumer mobile SIM, not to an aggregator.
- No HLR cache poisoning, because the live HLR query returns the same MCC/MNC every time for the lifetime of the SIM.
Real SIM over VoIP is not a feature here — it is the reason verification works in 2026. The consistently high success rate we publish on activations is the measured rate of SMS arrival on the SIM. When a verification does fail on a real-SIM number, it is overwhelmingly a platform-side issue (IP mismatch, behavioural reuse, country gating), not an SMS routing failure. And the auto-refund applies in every case where the SMS does not arrive within 20 minutes — you are never charged for a message that did not land.
See Full Access and Platform Rental options →Citation Capsule — Real carrier-issued SIM termination is structurally immune to the four MNP failure modes because the SIM has a fixed MCC/MNC and no porting history. The platform’s OTP is delivered directly to the SIM via the destination carrier’s SMSC, skipping the aggregator-routed MNP layer entirely — so there is no stale cache, no ported-range reputation flag, no bulk-sender filter, and no HLR cache poisoning. This yields a consistently high SMS-arrival rate across 145+ countries and 2500+ services, versus the 8-12% MNP loss on aggregator-routed traffic, with a 20-minute auto-refund on any non-arrival.
When Do You Want a Rental Instead of a Single Activation?
Not every verification need is a single OTP. Some workflows want a number that receives SMS from one service over days, an account that stays logged in across sessions, or a dedicated inbox for testing an integration. VirtualSMS covers those with two rental tiers, both on the same MNP-immune real carrier SIMs:
Full Access Rental — an entire real carrier SIM (any of our 145+ countries, any service) rented exclusively to you for 1, 3, 7, 14, or 30 days. Every SMS from any service routes to your private inbox. Right for developers integrating SMS workflows, teams testing across multiple services at once, or anyone who needs a dedicated number for weeks.
Platform Rental — a per-service rental on our global partner network, scoped to one specific service for 1, 3, or 7 days, with a 20-minute auto-refund if no SMS arrives. Cheaper than Full Access because you pay for one service slot rather than the whole SIM. Right for ongoing account management on a single platform or testing one service over multiple sessions.
Both tiers, like single activations, terminate on real carrier SIMs — so none of them inherit the 8-12% MNP loss that aggregator-routed numbers carry.
Compare SMS verification services in 2026 →Frequently Asked Questions
What is Mobile Number Portability (MNP) and what does it do to SMS verification?
Mobile Number Portability lets a subscriber keep their phone number when they change carriers. The MSISDN (the +44 7700 90xx xxx string) stays the same to the user, but the underlying routing changes — the IMSI tied to the new SIM, the carrier-of-record, and the MCC/MNC pair all update on the destination network. SMS verification platforms that route on the original number prefix instead of querying the live HLR send the OTP to the wrong carrier. Industry observation puts the silent failure rate at roughly 8-12% globally, and higher in markets like the UK and India where MNP usage exceeds 10% of mobile numbers. The failure is silent because the sender status callback often shows DELIVERED while the destination handset receives nothing.
How can I tell if a phone number has been ported?
Call an HLR lookup or Line Type Intelligence API. Twilio Lookup v2 returns mobile_country_code and mobile_network_code reflecting the carrier that currently holds the number; Telesign Phone ID returns a portability flag plus the original network id. If the MNC from the live lookup does not match the MNC implied by the number prefix, the number has been ported. Numverify and Numlookup expose simpler consumer-level checks on the same upstream HLR data. For high-volume sender flows, the query is cached against the national Number Portability Database — NPDB in the US, the Common Numbering Database for Ofcom in the UK, PortNet for Germany, or the equivalent registry.
Does MNP actually affect SMS verification, or is it a rounding error?
It is measurable, not a rounding error. When a sender uses cached MNP data older than a few days, the SMS routes to the old carrier, which either rejects the message (a clean failure you can retry) or accepts it and tries to redirect via SS7 (a dirty failure where the message queues for hours, duplicates, or drops). SS7 redirection works acceptably for voice calls but is unreliable for SMS — the originating carrier SMSC may drop the message or sit on it. Coupled with carrier reputation flags on ported ranges and bulk-list filtering, MNP-affected numbers fail SMS verification 8-12% of the time on aggregator-routed traffic, and up to 18% in India.
What is the difference between MNP and number recycling?
MNP changes the carrier behind a number while the subscriber stays the same. Number recycling assigns a previously-used number to a brand-new subscriber after a carrier-defined aging window, usually 45 to 90 days. Both trigger HLR record updates, but the failure modes differ. MNP causes routing errors at the SS7 layer — the OTP goes to the wrong network. Recycling causes account-graph conflicts — the new owner inherits OTP messages, account-recovery notices, and 2FA codes meant for the previous owner. MNP is a delivery problem; recycling is an identity problem.
Do real-SIM virtual numbers have MNP issues?
No, by structural design. When a real-SIM provider allocates a number for an activation, the SIM is a real carrier-issued SIM (not VoIP) sitting on a live mobile network. The platform sends the OTP straight to that SIM via the destination carrier SMSC — there is no aggregator route, no cross-border hop, and no MNP cache that can go stale. The terminating party for the SMS is the SIM itself, and its MCC/MNC pair is fixed because the SIM has no porting history. Verifications on real carrier SIMs do not lose 8-12% to routing; they hit the consistently high SMS-arrival rate we publish, even on heavily-ported number ranges in the UK and India.
Can I detect MNP via API, and how much does it cost?
Yes. The standard options are Twilio Lookup v2 (line_type_intelligence with mobile_country_code and mobile_network_code), Telesign Phone ID (portability status and original network id), and direct NPDB or national-registry queries for enterprise senders. Numverify and Numlookup expose cheaper consumer-grade endpoints with less granular MNP data. Twilio prices Line Type Intelligence at roughly $0.005-$0.01 per query depending on volume tier as of 2026 (check the live Twilio Lookup pricing page — these numbers change). That per-query cost is negligible next to the unit cost of a failed verification: a lost user, a support ticket, and a refund. HLR-before-send pays for itself once your silent-failure rate clears about 2%.
Which regulators run national MNP registries?
In the US, the Federal Communications Commission (FCC) sets the Local Number Portability (LNP) rules under 47 CFR Part 52, with the Number Portability Database (NPDB) operated by iconectiv under FCC oversight. In the EU, MNP falls under the Electronic Communications Code (Directive 2018/1972) and is administered nationally — Ofcom in the UK, Bundesnetzagentur in Germany, Arcep in France, ACM in the Netherlands. India MNP is overseen by the Telecom Regulatory Authority of India (TRAI); Brazil by ANATEL; Mexico by the IFT. The technical detail differs per registry, but the verification implication is identical — query the live record, not the prefix.
The Bottom Line
MNP breaks 8-12% of aggregator-routed SMS verifications for a simple, structural reason: the number’s prefix tells you the original carrier, the live HLR tells you who holds it today, and senders that route on the prefix send OTPs to the wrong network. The rate scales with porting — worst in the UK (9-11%) and India (12-18%), cleanest in Germany (1-2%).
If you run your own sender stack, the fix is HLR-before-send: query the live MCC/MNC with Twilio Lookup v2 or Telesign Phone ID, block non-mobile line types, and route on the post-port carrier. If you would rather not maintain that layer at all, real-SIM termination removes it — a real carrier SIM has a fixed MCC/MNC and no porting history, so none of the four MNP failure modes can fire.
VirtualSMS runs real carrier-issued SIMs across 145+ countries and 2500+ services, with Full Access and Platform Rental tiers for multi-day needs and an activation from $0.05. Most codes arrive in under 60 seconds — and if yours does not land within 20 minutes, the refund is automatic.
