NumVerify Alternative for Bulk Phone Validation

NumVerify is one of the most widely used phone validation APIs, and for good reason. It has a generous free tier, a simple JSON response, and it covers a large number of countries. If you are a developer who needs to validate a phone number here and there inside an application, NumVerify is a reasonable pick. But the moment your work shifts from validating individual numbers to cleaning entire outreach lists, the per-request metering model starts working against you, and a flat-priced NumVerify alternative becomes the cheaper and simpler choice. This guide is an honest comparison: what NumVerify does well, where its pricing pinches, and how PhoneVerify compares for bulk list cleaning.

We will keep the numbers grounded in NumVerify’s published 2026 pricing and be clear about which tool fits which job. NumVerify is not a bad product. It is a per-request phone validation API being asked to do per-list work, and that mismatch is what this article is really about.

What NumVerify does#

NumVerify (part of the APILayer family) takes a phone number and returns a JSON object describing it. The core fields are:

• valid: whether the number is a possible, well-formed number
• number / local_format / international_format: normalized representations
• country_code / country_name / location: geographic resolution
• carrier: the network behind the number where available
• line_type: mobile, landline, and so on, where available

That is a solid, practical set of fields for validation. It is roughly the same shape of data you need to clean an outreach list: validity, country, carrier, and line type. NumVerify resolves it cleanly for a single number, and the API is genuinely easy to integrate.

The catch is not the data. The catch is how you are billed for getting that data across thousands of numbers, repeatedly.

NumVerify pricing in 2026#

NumVerify prices by the number of API requests you can make per month. Here is the published shape of numverify pricing in 2026.

Plan	Price	What you get
Free	$0	100 requests per month, no time limit
Paid (entry)	from $14.99/month	Higher request volume, HTTPS, support
Higher tiers	scaling monthly fees	Larger request allowances
Platinum Support add-on	$479.88+/year	Priority support, tier-dependent
Overages	extra per-request fees	Charged after you hit your allowance

The free tier is real and useful for testing: 100 requests a month with no time limit. Paid plans start at $14.99 a month and scale up by how many requests you are allowed. Crucially, if you exceed your monthly allowance, overage fees kick in, which means a busy month can cost more than the plan’s sticker price.

The metering problem at list scale#

Every number you validate is one request. That sounds fine until you do the arithmetic on a real list.

Workload	Requests consumed	Pricing pressure
Validate 100 numbers	100	Fits the free tier once
Clean a 5,000-row list	5,000	Needs a mid paid tier
Clean a 50,000-row client database	50,000	Needs a high tier or triggers overages
Re-verify that 50,000 list monthly	50,000/month	Full allowance burned every month

The pattern is the same one that affects every per-request validator: the meter does not care that you are cleaning a list rather than checking a single number, and it does not care that you re-verify the same list every few weeks because phone data decays. Each re-verification spends your allowance again. A 50,000-row list re-checked monthly burns 50,000 requests a month, every month, forever.

When you blow past the allowance, overages apply, so your bill becomes unpredictable in exactly the months your outreach is busiest. For an agency trying to bake list hygiene into a flat retainer, an unpredictable per-request meter is the wrong foundation.

Where PhoneVerify fits#

PhoneVerify is built for the batch case rather than the per-request case. You upload a CSV, every row is validated against the global numbering plan and carrier metadata, and you download a tagged file with validity, line type, carrier, and timezone appended to each original row. Pricing is flat and volume-based, so re-verifying a list does not re-burn an allowance the way per-request metering does.

The honest framing: NumVerify and PhoneVerify return broadly the same validation fields. The difference is the delivery model and the pricing. NumVerify is an API you call once per number and pay for per request. PhoneVerify is a bulk tool you hand a whole file and pay for by plan volume. If your work is per-number, NumVerify’s model is fine. If your work is per-list, the flat model wins.

NumVerify vs PhoneVerify: feature comparison#

For anyone searching numverify vs alternatives, here is the side by side.

Capability	NumVerify	PhoneVerify
E.164 validation	Yes	Yes
Country / location	Yes	Yes
Carrier	Yes (where available)	Yes
Line type (mobile/landline/VoIP)	Yes (where available)	Yes
Timezone	Limited	Yes
Bulk CSV upload and download	No (API per request)	Native, built-in
Pricing model	Per monthly request, plus overages	Flat bulk
Re-verification cost	Burns allowance every time	Covered by plan
Free tier	100 requests/month	Try a number free
Best fit	In-app single-number validation	List cleaning, outreach hygiene

Pricing model comparison#

The real decision is not “which is cheaper” in the abstract; it is which model matches your workload.

• Per-request (NumVerify): efficient when you validate a number at a time, occasionally, inside an application. At low volume the free tier or a small plan is hard to beat.
• Flat bulk (PhoneVerify): efficient when you validate many numbers at once, on a schedule. Cost per number drops as volume rises, and re-verification does not re-spend an allowance.

If you validate a few hundred numbers a month inside a signup form, NumVerify is the right tool and may even stay free. If you clean fifty thousand numbers a month across client lists and re-verify them regularly, flat bulk pricing is the obvious answer.

When NumVerify is the right choice#

To be fair, NumVerify earns its place in several cases:

• In-application validation. You want to validate a phone number as a user types it in a form, one request at a time. That is exactly what NumVerify’s API is for.
• Low, predictable volume. If you stay comfortably inside a plan’s request allowance, the cost is small and the overage risk is low.
• Developer-first integration. You want a clean JSON API to call from your own code rather than a CSV tool, and you are happy to handle the batching and storage yourself.

In those situations, reaching for a bulk tool would be overkill. The mismatch only appears when you point a per-request API at a whole list.

When a NumVerify alternative makes more sense#

Switch to a flat-priced bulk verifier when your workload is list cleaning:

• Your input is a CSV, not a single number. You are cleaning exports from scrapers, CRMs, or client handoffs with thousands of rows.
• You re-verify on a schedule. Phone data decays, so you re-run lists every few weeks. Per-request metering punishes this; flat pricing does not.
• You need predictable costs. Overage fees in your busiest months are the opposite of what an agency retainer needs.
• You want segmentation built in. A bulk tool returns a tagged file you can immediately split by line type, rather than raw JSON you have to assemble yourself.

This is the same tradeoff that shows up against the other big validators. Twilio Lookup meters per lookup per package, which is the same per-request shape; we cover that in the Twilio Lookup alternative guide. IPQualityScore uses a credit system where phone validation costs several credits per lookup, covered in the IPQualityScore phone validation alternative guide. Across all three, the common thread is per-request pricing meeting per-list work.

A practical bulk-validation workflow#

Here is the batch workflow, whichever tool you are migrating from.

1. Get the raw list into a CSV#

If you are building lists, the Google Leads Scraper pulls local businesses by niche and city and exports phone numbers straight to CSV, the exact input bulk validation expects. For social-led prospecting, the Free Social Media Scraper gathers public profile data you can enrich and validate the same way. Treat every export as raw, never as call-ready.

2. Clean the phone column#

Prefer E.164 format (+ country code national number, no spaces or dashes). Watch for spreadsheets stripping leading zeros or converting long numbers to scientific notation, the most common cause of false “invalid” results. The bulk phone verification guide covers file prep in detail.

3. Validate the whole file at once#

Upload the CSV to PhoneVerify and let it tag every row with validity, line type, carrier, and timezone. No per-request meter, no batching code, no overage anxiety.

4. Segment on line type#

Send SMS only to mobiles. Never text landlines, they fail silently with no error and no delivery. Flag VoIP separately for compliance. The Mobile vs Landline vs VoIP guide explains why this field decides your routing, and SMS list validation for SMMA walks the SMS-specific version of this for agencies.

5. Re-verify regularly#

Phone data decays continuously, so re-run lists every few weeks. Flat bulk pricing means the tenth run costs the same as the first, which is exactly what recurring hygiene needs.

A worked example: cleaning a 50,000-row client database#

To make the tradeoff concrete, walk through a realistic agency job: a new client hands you a 50,000-row contact database scraped and stitched together from several sources, and you need it call-ready and text-ready.

On a per-request model, that single clean is 50,000 requests. Depending on the plan you are on, that either consumes most of a high tier’s monthly allowance in one job or spills into overage fees. Then the client wants the list refreshed monthly because they keep adding leads and the old numbers decay, so you are back to 50,000 requests every month. Add a second client with a similar database and you have doubled your request load and likely pushed into overages on both. Your tooling cost is now a moving target driven by client count and list size, and you are doing allowance arithmetic instead of outreach.

On a flat bulk model, the same job is one upload. The monthly refresh is another upload. The second client is another upload. None of it moves a meter, because the plan is sized by volume rather than by request count, and re-verification does not re-bill. You can quote both clients a fixed hygiene cost, re-verify on whatever cadence keeps connect rates high, and never touch overage math. That is the practical difference the worked example exposes: not a few cents per number, but a fundamentally different and more predictable cost structure for the exact workload agencies run.

The output of that clean is the same either way, a tagged file split into valid mobiles (call and text), valid landlines (call only), VoIP (flagged for compliance), toll-free (usually dropped), and invalids (dropped). What changes is what it costs you to produce that file the first time and every time after.

Migrating off NumVerify without breaking your stack#

If you already call NumVerify from your own code, migrating to a bulk verifier is usually a simplification rather than a rewrite, because you are removing per-request plumbing rather than adding it.

Step one: find your two usage patterns#

Look at where you call NumVerify. You will typically find two patterns. The first is in-application: a single number validated as a user submits a form, one request, acted on immediately. The second is batch: a loop over a CSV, a CRM export, or a database table, calling NumVerify once per row. The first pattern is exactly what NumVerify’s API is built for and is worth keeping if you still need real-time in-form validation. The second pattern is the one burning your monthly request allowance, and it is the one to move.

Step two: turn the loop into an upload#

Every batch loop already has a list behind it. Instead of iterating row by row and spending a request each time, export the rows and upload the file to PhoneVerify in a single pass. You get back the same validity, country, carrier, and line-type fields you were pulling out of NumVerify’s JSON, plus timezone, with no request counting, no allowance to watch, and no overage risk. You also get to delete the batching, throttling, and retry code that the loop required.

Step three: decide whether you still need the API at all#

Many teams find that once the batch work moves to a bulk uploader, the only remaining NumVerify calls are a handful of real-time in-form validations, light enough to sit inside the free tier or a small plan. Others drop the API entirely and do all validation in bulk. Either is fine; the goal is to stop pointing a per-request meter at per-list work.

The hidden costs of per-request metering#

NumVerify’s per-request model carries costs beyond the plan’s sticker price, the kind that surface in engineering time and in surprise overage line items rather than on the pricing page.

Allowance accounting. When every number is a request, you have to track how close you are to your monthly cap, and decide what happens when you hit it: stop, throttle, or pay overages. That is logic you build and babysit. A flat bulk plan removes the accounting entirely.

Overage exposure in busy months. Overage fees apply once you pass your allowance, and you pass your allowance in exactly the months your outreach ramps up. So your validation cost spikes precisely when your campaign volume, and your need for clean data, is highest. That is the worst possible time for an unpredictable bill.

Re-verification burns the allowance again. This is the structural issue. Phone data decays, so you re-verify lists every few weeks, and each re-verification spends the full request count again. A 50,000-row list re-checked monthly consumes 50,000 requests a month, every month, which on most paid tiers means either a large plan or recurring overages. Flat bulk pricing turns that recurring consumption into a fixed cost.

Batching and retry plumbing. To push a large list through a per-request API you batch, throttle, and retry failures, and some failures still count against you. That glue code is real maintenance that a bulk uploader makes unnecessary.

How agencies should think about this#

For an agency, the NumVerify decision comes down to predictability and margin. Hygiene is a cost you fold into a client retainer, and a retainer needs a number you can commit to in advance.

A per-request meter with overage fees fights that directly. You cannot promise a client a fixed monthly hygiene cost when your tool charges by how many numbers you validated that month and adds overage fees if a list runs bigger than expected. Onboard a client with a 200,000-row database one month and a quiet client the next, and your tooling cost swings around even though your service did not change.

Flat bulk pricing lets you clean and re-clean as many client lists as the work requires for a cost you set going in. You can take on a large client and a small client on the same plan, re-verify everyone as often as the data demands, and keep your margin stable. And because re-verification does not re-burn an allowance, your team re-verifies on the right schedule for connect rates and caller reputation, instead of stretching the interval to dodge overages.

Accuracy and coverage: how the two compare#

It is reasonable to ask whether moving off NumVerify costs you data quality. For the fields outreach actually uses, it does not, because both tools resolve the same kind of carrier-level numbering data.

Validity, country, and carrier come from the global numbering plan and carrier metadata. Line type, mobile, landline, VoIP, toll-free, is resolved from the same layer. NumVerify exposes these fields where its data covers the number, and PhoneVerify does the same, so for the routing decisions that matter (can I text this, what region is it in) the practical output lines up. PhoneVerify additionally returns timezone on every row, which NumVerify treats as more limited, and timezone is genuinely useful for scheduling dial sessions inside local business hours.

The honest caveat that applies to every validator: carrier identification can be muddied by number portability, since the current network may differ from the original block owner. That is a property of the numbering system, not a weakness of one vendor over another. Neither tool magically knows a number is “fake” beyond what line type and validity tell you, which is a separate point from fraud scoring that we cover in the IPQualityScore phone validation alternative guide.

Clean the email channel too#

If your outreach is multi-channel, hold your email list to the same standard. Run your addresses through the email verifier to catch dead mailboxes, disposable domains, and risky catch-alls before you send, so your follow-ups do not bounce and harm your sending domain.

And when your data is clean across phone and email, the teams running this at real volume, verifying, segmenting, sequencing, and following up across many clients, do it on Inflowave, the all-in-one platform for lead generation, outreach automation, and client growth.

Frequently asked questions#

Is PhoneVerify a drop-in replacement for NumVerify?#

For bulk list cleaning, yes. PhoneVerify returns the same practical validation fields, validity, line type, carrier, and timezone, but as a bulk CSV tool at flat pricing instead of a per-request API. If you specifically need a JSON API to call from your own application code one number at a time, NumVerify’s API model may still suit you better.

How does NumVerify pricing actually work?#

NumVerify charges by the number of API requests per month. The free tier allows 100 requests a month, paid plans start at $14.99 a month with larger allowances, and exceeding your allowance triggers overage fees. Every number validated counts as one request, so list cleaning consumes the allowance quickly.

Why is per-request metering bad for list cleaning?#

List hygiene is recurring batch work. Per-request metering spends your allowance every time you validate, and lists decay so you re-verify often. A 50,000-row list re-checked monthly burns 50,000 requests every month. Flat bulk pricing charges by plan volume instead, so re-running a list does not re-spend an allowance or trigger overages.

Does PhoneVerify match NumVerify on country coverage and accuracy?#

Both resolve validity, country, carrier, and line type from carrier-level numbering data, so for the fields that drive outreach decisions the practical results line up. PhoneVerify additionally returns timezone, which is valuable for scheduling dial sessions inside local business hours.

What about Twilio Lookup and IPQualityScore?#

Both are also per-request models. Twilio meters per lookup per package, and IPQualityScore uses credits where phone validation costs several per lookup. The same bulk-versus-per-request tradeoff applies. See the Twilio Lookup alternative and IPQualityScore phone validation alternative guides.

Does verification call or text the numbers?#

No. Verification is rules-based. It checks each number against the global numbering plan and carrier metadata to determine validity, line type, carrier, and timezone. It does not place calls or send messages, so it does not alert the contact or consume dialer or SMS credits.

The bottom line#

NumVerify is a clean, capable per-request phone validation API with a genuinely useful free tier, and for in-application, single-number validation it is a fine choice. It is the wrong shape for cleaning outreach lists at scale, where per-request metering and overage fees punish the recurring batch work that list hygiene actually is. For that job, a flat-priced bulk verifier is the honest answer.

Paste a single number into the PhoneVerify checker to see the fields, then upload your whole CSV and clean the entire list, no per-request meter, before your next campaign.