# Mobile number portability: why carrier lookups can be wrong

> A number's prefix shows the network its range was given to, not the one serving it today. How porting works, where lookups fail and how to handle it.

Canonical: https://mobilevalidate.com/blog/mobile-number-portability-why-carrier-lookups-can-be-wrong · Last updated: 2026-09-25

![Cover: Mobile number portability: why carrier lookups can be wrong](https://mobilevalidate.com/og/blog/mobile-number-portability-why-carrier-lookups-can-be-wrong.png)


By MobileValidate team (https://mobilevalidate.com/about) · Published: 2026-09-25 · Category: Guides · Tags: Mobile number portability, Carrier lookup, SMS routing, Line type, Fraud prevention

A carrier lookup can be wrong because a phone number's digits describe the network its range was **allocated** to, not the network that **serves** it today. When a subscriber keeps their number and switches operator, which regulators in most competitive markets guarantee, every prefix-based guess about that number becomes outdated. Reliable answers need current data about the specific number.

## Why doesn't the prefix tell you the network any more?

Numbering plans hand out numbers in blocks. A regulator gives an operator a range, and for years the first digits of a mobile number really did identify the network. Many systems still work that way: a table maps prefixes to operators, and the table is right as long as nobody moves.

Mobile number portability (MNP) broke that link on purpose. It lets a subscriber take their number to a competitor, so that changing operator no longer means changing number. After the move, the number stays in the old operator's block, but calls and texts must go to the new one.

The prefix table doesn't know. It still says "Operator A" for a number now on Operator B. Even open-source numbering libraries document this. [Google's libphonenumber](https://github.com/google/libphonenumber) ships a carrier mapper that returns the original range holder, not the current network ([Google, 2026](https://github.com/google/libphonenumber)). That is the right answer to a different question.

## How common is porting, and where does it apply?

Portability is a regulatory obligation in the markets most businesses message:

| Market | What the rules say | Source |
|---|---|---|
| United States | Wireless number portability since November 2003 in the top 100 metropolitan areas, May 2004 elsewhere. Numbers can also move between landline and wireless service | [FCC](https://www.fcc.gov/general/wireless-local-number-portability-wlnp) |
| Canada | Wireless number portability required from 14 March 2007 in the main markets, with a phased rollout elsewhere | [CRTC, 2005](https://crtc.gc.ca/eng/archive/2005/dt2005-72.htm) |
| European Union | Article 106 of the European Electronic Communications Code gives end-users the right to port; Article 106(5) requires the number to be activated with the new provider within one working day of the date agreed with the end-user | [EU, 2018](https://eur-lex.europa.eu/eli/dir/2018/1972/oj) |

Outside these, most countries with competitive mobile markets offer MNP in some form, but the mechanics differ. Some run one central database that every operator queries. Others leave the number with its original operator, which forwards traffic onward. The practical point is the same everywhere: after two decades of porting, you should assume any given number may have moved, and in the US it may also have changed line type.

## How do networks find a ported number?

Networks need to route calls and texts correctly, so they keep track of ports. The common designs:

- **Central database.** A national database lists every ported number and its current network. Operators query it or keep a synchronized copy.
- **Distributed copies.** Each operator keeps its own list, updated by messages from the others.
- **Onward routing.** Traffic goes to the original range holder first, which knows where the number went and passes it on.

Commercial lookups read the result of these processes in one of two ways. A **database lookup** reads porting data, directly where licences allow or from a regularly refreshed replica. A **live network query** (an [HLR lookup](/glossary/hlr-lookup)) asks the number's home register, whose reply shows the network that holds the subscription as an [MCC/MNC code](/glossary/mcc-mnc), the network identity defined in ITU-T E.212 ([ITU](https://www.itu.int/rec/T-REC-E.212/en)). The comparison is in [HLR vs MNP vs number validation](/blog/hlr-vs-mnp-vs-number-validation).

## In what ways can a carrier lookup be wrong?

Even with current data, several things produce a wrong or confusing carrier:

| Failure | What happens | How to spot it |
|---|---|---|
| Prefix guessing | The original range holder is returned for a ported number | Results never show a port, even for numbers you know moved |
| Stale replica | A port completed recently isn't in the copy yet | The customer says they switched this week; the lookup disagrees |
| Ported back | A number returned to its original operator is shown as still ported | Rare, but explains "ported to itself" oddities |
| Virtual operators (MVNOs) | The brand the customer sees runs on another operator's network | The carrier name doesn't match the customer's bill |
| Mergers and rebrands | Operator names change faster than reference data | Two names for what the customer calls one company |
| Change of line type | In the US a landline number can move to wireless or VoIP | Numbering plan says "fixed", lookup says `mobile` or `voip` |
| Masked network replies | Some operators hide the real network in live queries | Live answers show the same network for every number |

None of these mean the data is useless. They mean the carrier field is a **fact with a timestamp**, not a permanent property of the number.

## Why does a wrong carrier matter?

Three kinds of cost follow from a carrier error:

- **Routing and pricing.** Some messaging routes and wholesale rates are set per destination network. Routing a ported number by its prefix can send traffic down a more expensive or less reliable path.
- **Wrong line-type assumptions.** Where numbers move between services, as in the US, a range-based "fixed line" might now be a mobile, and a range-based "mobile" might now be VoIP. Filtering SMS by range type drops good numbers and keeps bad ones. See [line type](/glossary/line-type).
- **Missed fraud signals.** In a *port-out scam*, a criminal moves a victim's number to a SIM they control and then receives the victim's one-time passcodes. NIST's 2025 authentication guidelines list number porting, next to SIM change and device swap, among the risk indicators a verifier should consider before sending a code by phone ([NIST, 2025](https://csrc.nist.gov/pubs/sp/800/63/b/4/final)).

The last point is why you shouldn't treat porting as noise to filter out. A port is ordinary, but a port right before an account-recovery attempt is exactly the pattern to catch.

## How do you detect a ported number with MobileValidate?

The [carrier lookup](/services/carrier-lookup) returns `carrier`, the network serving the number as far as our data shows, and `original_carrier`, the network its range was allocated to. `original_carrier` appears **only when it differs**, so its presence is the porting signal. It covers all countries in real time or bulk and is labelled beta because coverage varies by country; a number we hold no data for returns `unknown` with reason `NO_DATA` and is free.

For US and Canadian numbers, the [US/CA carrier lookup](/services/us-carrier-lookup) returns `line_type` and the current `carrier` in bulk jobs. This matters there because numbers move between landline, wireless and VoIP.

A real test-mode job with `network.carrier_us` (excerpt of one result row):

```json
{"e164": "+12025550143", "country": "US",
 "checks": {"network.carrier_us": {"status": "completed", "registered": true,
   "attributes": {"line_type": "mobile", "carrier": "Test Carrier"},
   "checked_at": "2026-09-25T16:14:46.219Z", "billed": false, "reason": null}}}
```

Test data never includes a port. Live answers add `original_carrier` to `network.carrier` results when the number moved. The [HLR lookup](/services/hlr-lookup), **coming soon**, will add a live `ported` flag and the current network's `mcc_mnc`.

## How should your code handle porting?

Treat the carrier as time-stamped data and compare it with what you saw before. A minimal pattern in TypeScript:

```ts
type Carrier = { carrier?: string; original_carrier?: string; line_type?: string };

function portingSignals(now: Carrier, checkedAt: string, previous?: Carrier & { checkedAt: string }) {
  return {
    ported: Boolean(now.original_carrier),          // present only when it differs from carrier
    carrierChanged: previous ? previous.carrier !== now.carrier : false,
    lineTypeChanged: previous ? previous.line_type !== now.line_type : false,
    checkedAt,
  };
}
```

Then act on the signals in context:

| Signal | Suggested action |
|---|---|
| `original_carrier` present | Route and price by `carrier`, not by prefix. No other action |
| `carrier` changed since your last check, no sensitive action | Update your record |
| `carrier` changed shortly before a 2FA or password reset | Step up: confirm through another channel you already trust |
| `line_type` changed from `mobile` to `voip` or `fixed_line` | Re-evaluate the channel; don't keep sending SMS by habit |
| `unknown` (`NO_DATA`, timeout) | Keep your previous routing; the check is free |

Store `checked_at` with every stored carrier. A carrier seen a year ago is a hint; one seen today is evidence.

## How often should you refresh carrier data?

It depends on what you use it for:

- **Routing live traffic:** look up at send time, or cache for a short window. Our account cache serves repeat checks of the same number inside the freshness window for free; `max_age: 0` forces a fresh, billed check.
- **Account security:** check when contact details change and before sensitive actions, then compare with the stored value.
- **Lists and CRM hygiene:** refresh in a bulk job before each campaign to consented contacts, or on a schedule such as quarterly. See [cleaning a phone list in bulk](/blog/how-to-clean-a-phone-number-list-in-bulk).

You're not charged for inconclusive results (unknown, unsupported country, timeout, invalid, duplicate). See [pricing](/pricing).

## What are the key takeaways?

- A prefix identifies the network a range was allocated to. After a port, it names the wrong network.
- Portability is a legal right in the US (since 2003–2004), Canada (since 2007) and the EU (activation within one working day), and exists in most other competitive markets.
- Carrier data can still lag, hide MVNOs or show old brand names. Treat it as a timestamped fact.
- Route and price by current network; use a change of carrier as context, especially right before account recovery.
- In MobileValidate, `original_carrier` in the carrier lookup marks a port; the US/CA lookup covers North America in bulk; a live `ported` flag arrives with the HLR lookup.

## Sources

1. [Wireless Local Number Portability (WLNP)](https://www.fcc.gov/general/wireless-local-number-portability-wlnp) — FCC, 2004
2. [Telecom Decision CRTC 2005-72: Implementation of wireless number portability](https://crtc.gc.ca/eng/archive/2005/dt2005-72.htm) — CRTC, 2005
3. [Directive (EU) 2018/1972 establishing the European Electronic Communications Code](https://eur-lex.europa.eu/eli/dir/2018/1972/oj) — European Union, 2018
4. [NIST SP 800-63B-4: Digital Identity Guidelines, Authentication and Authenticator Management](https://csrc.nist.gov/pubs/sp/800/63/b/4/final) — NIST, 2025
5. [Recommendation ITU-T E.212: The international identification plan for public networks and subscriptions](https://www.itu.int/rec/T-REC-E.212/en) — ITU, 2016
6. [libphonenumber](https://github.com/google/libphonenumber) — Google, 2026

## Frequently asked questions

### Can I find a number's carrier from its prefix?

Only the carrier its range was originally allocated to. Once a number has been ported, the prefix points to the wrong network. You need data about the specific number, such as a carrier lookup or a live network query.

### Is a ported number a fraud signal?

Not on its own. Porting is a normal consumer right and very common. A port becomes relevant when it is recent and followed by a sensitive action, such as a password or 2FA reset.

### Why can a carrier lookup be out of date?

Most lookups read porting data from a database or a replica that is refreshed on a schedule. A port completed in the last hours may not be visible yet. A live network query reflects the current state but only works for mobile numbers.

### What does original_carrier mean in the MobileValidate carrier lookup?

It is the network the number range was first allocated to. It appears only when it differs from carrier, the network serving the number today, which usually means the number was ported.