What phone validation actually costs

Phone validation is priced per lookup almost everywhere, which makes it cheap to try and surprisingly expensive to operate. The unit price looks trivial. The bill is a function of list size times how often you re-run, and the second term is the one people forget.

How per-lookup pricing actually bills

The unit price is the part everyone compares. It is rarely the part that decides the invoice. Four things sit underneath it, and none of them appear on a pricing page in a form you can compare.

• A failed or empty lookup is usually still a lookup. If a number is malformed, or the provider has no data for it, you are charged for the query in most pricing models. That means the junk rows in your file are billed at the same rate as the good ones.
• Fields are priced separately. Format validation, line type, carrier and caller name are commonly different products at different rates. A quoted headline price often covers the cheapest of them, not the one you actually need.
• Volume tiers need commitment, not just volume. The rate that makes a large list affordable is typically a monthly minimum or an annual contract. A one-off clean of 200,000 rows does not qualify for the 200,000-row price.
• Caps behave differently from meters. A capped plan stops or throttles; a metered plan keeps going and keeps charging. Neither is worse in the abstract, but they fail in opposite directions, and you should know which one your provider does before a bulk job runs overnight.

None of that is sharp practice. It is what per-row pricing looks like when you actually operate it, and it is why the useful question is not "what is the rate" but "how many rows will I send, how often, and how many of them did I already know were dead".

Published rates

Checked September 2026. Providers change pricing, verify current rates before you rely on these.

Worked example: 100,000 numbers

The re-run column is the point. Validation is not a one-time event: the list grows, contacts get re-exported, and a list validated in January is materially stale by June. Whatever your first run costs, budget for it repeatedly.

The same arithmetic at 1,000,000 rows

Scale changes which term dominates. At 100,000 rows the unit price is the story. At a million, the re-run frequency is.

The 40% figure is illustrative and varies enormously by list, which is the point of measuring your own rather than trusting a number in an article. A double-opted-in list from your own signup form will barely move. A merged or purchased list can lose more than half before any API is involved.

For reference on the time cost of that pre-pass: Phonelint processes 1,000,000 numbers in 21.2 seconds, roughly 47,000 per second, measured on a mid-range Windows laptop. The reason that matters here is not speed for its own sake. It is that a pre-pass which takes twenty seconds gets run every time, and one that takes four hours gets skipped.

Where the money actually goes

Here is the part that changes the arithmetic. On a typical messy list — bought, scraped, form-filled, or merged across systems, a large share of rows can be ruled out without any API call at all:

• Duplicates, once numbers are normalised to a canonical form
• Malformed numbers: wrong length, stray trunk prefix, junk characters
• Numbers in blocks the numbering authority never allocated
• Landlines, in the many countries whose plan separates them by range

All four are answerable from published numbering-plan data — deterministic, instant, no per-row cost. Paying $0.008 to be told that +1 999 999 9999 is not a real number is paying for arithmetic you could have done locally.

The two-pass approach

Filter locally first, then spend on what survives:

100,000 raw rows
  -  8,000  duplicates            free
  -  6,000  malformed             free
  - 14,000  unallocated blocks    free
  - 12,000  landlines             free
  ------------------------------------
    60,000  to live lookup        $480 at Twilio rates
                                  (vs $800 unfiltered)

The proportions vary enormously by list, a double-opted-in list from your own signup form will barely move, a scraped list can lose more than half. The principle holds either way: never pay per lookup for a number that a free check already ruled out.

The cost that is not on any pricing page

Every metered provider works the same way at the point of use: your list goes to their servers. For a list of your own subscribers that may be a decision you are comfortable making. For a client's customer data held under a DPA, or any list with EU residents in it, it is a processor relationship with paperwork attached.

Under Article 28 of the GDPR a controller may only appoint a processor that offers sufficient guarantees, and the arrangement has to be governed by a contract setting out the subject matter, duration, nature and purpose of the processing. That is a procurement conversation, a data-processing agreement, and a record you have to maintain, per vendor.

Agencies feel this more sharply than in-house teams, because the data is not theirs to upload in the first place. Validation that runs locally removes the question rather than answering it: there is no transfer, so there is no processor to appoint. That is not a privacy nicety, it is a line item made of legal time.

Measure your own list before you buy anything

Every figure in this article is someone else's list. Yours will differ, often by a lot, and the difference decides whether a metered API is a sensible purchase or an expensive way to discover you had 30,000 duplicates.

You can establish the shape of it without spending anything:

1. Count the rows you have, then count the distinct rows after normalising to E.164. The gap is your duplicate rate. Do it in that order: deduplicating raw strings misses the same number written three ways, which is the common case in any list merged from more than one system.
2. Count what fails a format check. Wrong length for the country, stray trunk prefix, letters in the field, a column that turned out to be extensions. These cost full price at a metered provider and resolve to nothing.
3. Count what sits in unallocated blocks. This is the number that usually surprises people, because those rows look perfectly well-formed and pass every syntax check.
4. Count the landlines, in the countries whose plan separates them by range.

Add those four together and you have the proportion of your file that a local pass removes before any money is spent. Whatever remains is the real size of the job you are pricing. Running that count on a sample of a few thousand rows is enough to estimate the whole file, and it converts a purchasing decision that is currently a guess into arithmetic.

It is also the honest way to find out that you do not need a paid tool. A clean, double-opted-in list from your own form will lose very little at every one of those four steps, and for that list a metered lookup on the small ambiguous remainder is a perfectly good answer.

When a live lookup is still worth it

Local data has a real boundary, and being straight about it matters more than the sales pitch:

• Ported numbers. Block data reflects the original assignment. A number that moved carriers reads as its old one. Live lookup resolves this; local data cannot.
• Current carrier for a specific segment, where routing or compliance depends on getting it exactly right.
• Caller-name (CNAM) data, which is not in numbering-plan data at all.

So the answer is not "APIs are a rip-off". It is that they are priced for resolving genuine ambiguity, and most of a raw list is not ambiguous. it is plainly, checkably dead.

What the same job looks like without a meter

A one-time purchase changes the shape of the decision rather than only the size of the number. With a meter, every re-run is a fresh approval: someone has to decide the clean is worth $800 this month. Without one, re-running is free, so the list gets cleaned before every send instead of quarterly when someone remembers.

Phonelint is $29, one device, unlimited local validation, with a 14-day refund on the retail tier. The honest framing is not that it replaces a lookup API. It replaces the first pass, which is the pass containing almost all of the rows and almost none of the ambiguity.

One practical caveat before the maths tempts anyone: it is Windows only, and it is not code-signed, so SmartScreen shows "Windows protected your PC" the first time you run it. Better said here than discovered after paying.

The other cost

Beyond the lookup bill: sending to a dead list costs you the messages, and it costs you carrier reputation. Delivery-failure rates feed into how carriers treat your traffic, and a throttled or filtered sender is a much larger problem than a validation invoice. That cost does not appear on any provider's pricing page, which is precisely why it gets left out of the calculation.

Common questions

Is there a free phone number validator available?

Yes. Our free cleaner handles E.164 normalisation, deduplication, country detection and malformed rows for up to 50,000 numbers, in your browser, with nothing uploaded. What free tools generally cannot do is line type, carrier or block allocation, because those require a numbering-plan database rather than a page of script. Free tiers on paid APIs exist too, and are usually sized as a trial rather than a workflow.

Can a phone validator detect fake numbers?

It can reliably detect numbers that cannot exist. A number outside any allocated block, or with the wrong length for its country, is deterministically invalid and no live lookup will disagree. What no validator can tell you is whether a real, allocated number belongs to the person who typed it. Detecting an unreachable number and detecting a dishonest one are different problems, and only the first is solvable from data.

How do I validate my phone number list?

In order: normalise every row to E.164, deduplicate after normalising rather than before, drop numbers in unallocated blocks, separate landlines from mobiles, then send only what survives to a metered lookup if you still need live carrier data. Doing it in that order is what keeps the paid step small.

Is phone validation worth paying for?

It depends which part. Paying per row to be told a malformed number is malformed is paying for arithmetic. Paying to resolve a genuinely ambiguous number, such as one that may have been ported to a different carrier, buys you something local data cannot produce. The cost-effective pattern is to make the free step do all the work it can before the paid step starts.

Is the Twilio Lookup API free?

Basic format validation is free; the fields most people actually want are not. Line Type Intelligence was $0.008 per request when checked in September 2026, billed per lookup. That split is common across providers: the free tier covers the check you could do yourself, and the paid tier covers the carrier-derived data you cannot.