Best Reverse Phone Lookup APIs in 2026: Pricing, Data & Accuracy Compared

Here's a number that stopped me cold. The keyword reverse phone lookup api carries a cost-per-click of $19.90, and its cousin caller id api sits even higher at $22.79 (DataForSEO, August 2026). Advertisers pay twenty bucks for a single click on a keyword that gets 90 searches a month. Twenty dollars. Per click.

That tells you everything. When a phone number can be turned into a name, a carrier, and a line type in one API call, the data underneath is worth real money to the people buying it: fraud teams, sales ops, dialers, onboarding flows. So the market is crowded. And loud. And, honestly, most of the comparisons you'll read were written by one of the vendors being compared.

This one isn't. We build lead data at Scrap.io, but not the kind that identifies a random caller, so we've got no dog in the Trestle-versus-Twilio fight. What follows is a straight look at the best reverse phone lookup APIs in 2026: what they cost, how accurate they actually are, where the free tiers end, and one angle nobody else covers (getting business phone numbers in the first place). Let's get into it.

What Is a Reverse Phone Lookup API?

A reverse phone lookup API is a service you send a phone number to and get structured data back: the owner's name, the carrier, the line type (mobile, landline, or VoIP), and often the location or demographics. One request in, a clean JSON response out. That's the whole idea.

Think of it as the reverse of the problem you usually have. Normally you're trying to find a phone number by name. A reverse phone number lookup api flips that: you already have the number, you want to know who's behind it. Some people call it a phone number reverse lookup api, some say number-to-name (CNAM), some just want to answer the eternal question, "who called me from this number?"

Developers reach for a phone number lookup api in a few recurring situations. Cleaning junk leads before they hit the CRM. Screening signups for fraud. Building a caller ID pop for a support team. Enriching a contact record with carrier and line-type intelligence before a campaign goes out. Different jobs, same building block.

How Does a Reverse Phone Lookup API Work?

Under the hood it's less magic than you'd expect. Three steps, basically.

1. Send the number (E.164 format). Your app posts a number like +12128148373 to the API endpoint. E.164 is the international standard: country code, then the national number, no spaces or dashes. Clean input matters.
2. The API does the lookup. It queries carrier databases and public records, runs a CNAM lookup (that's the caller-name database carriers maintain), and cross-references identity sources to attach a name and address.
3. You get JSON back. Name, carrier, line type, prepaid flag, sometimes a fraud score or an HLR lookup result telling you whether the line is even reachable.

That middle step is where the providers actually differ. Some lean on telecom CNAM data. Some blend in 30 years of public records. Some bolt on a fraud-scoring layer. The endpoint looks identical from the outside. The data quality behind it? Wildly different.

CNAM, caller ID, and line type detection

A quick vocabulary detour, because these terms get muddled constantly. A caller id api (or CNAM lookup api) answers "what name is registered to this number?" A line type detection api answers "is this a mobile, a landline, or a VoIP line?" And an HLR lookup api pings the carrier network to check whether a mobile number is currently active. Most serious providers roll all three into one response. If you're trying to figure out whether a number is a mobile before firing off an SMS, that line-type field is the one you care about. We wrote a whole guide on running a cell phone or landline lookup if you want to go deeper on that specific problem.

The 8 Best Reverse Phone Lookup APIs in 2026

Here's the part where most comparison articles get shady, because the person writing them sells one of the tools. So I'll say it plainly: I've grouped these by tier, listed real pricing where it's public, and flagged the weaknesses too. Nobody's perfect. Let's go.

Tier 1: The identity heavyweights

Trestle Reverse Phone API. Probably the cleanest identity play on the market. Trestle turns a number into a full owner profile: name, current address, demographics, line type, carrier, prepaid status. The numbers behind it are serious, 479 million identities, 1.03 billion phone-to-name linkages, 90%+ accuracy, coverage across 100+ countries, up to 1,000 QPS, and 99.99% uptime (Trestle). Self-service pricing is refreshingly honest at $0.07 per query. If you need to know who owns a US number, start here.

IPQualityScore (IPQS). Same core data, different angle. IPQS is built around fraud: spam scoring, VoIP detection, abuse velocity, risk flags, all in the same call as the standard name and carrier fields. It returns JSON or XML, and the free tier is genuinely useful (1,000 lookups to test with). If your reason for looking up a number is "should I trust this person," IPQS is the pick (IPQS).

Twilio Lookup API. The default when your stack already runs on Twilio. Lookup returns line type, carrier, formatting, and fraud signals from a single endpoint, and it plays nicely with Twilio's SMS and voice tooling. Base validation is free to use; line-type intelligence runs roughly $0.05 per verification (around $8 per 1,000 for line type). Not the cheapest, but if you're already paying Twilio, the integration friction is basically zero (Twilio).

Tier 2: Budget, dev-friendly, and open source

Numverify. Owned by APILayer, JSON-first, no-nonsense. Returns validation, carrier, and line type. Free tier is 100 requests a month, with paid tiers scaling from there. It's the tool people reach for when they're building an MVP and don't need fraud scoring.

Abstract API Phone Validation. Clean docs, predictable pricing from around $19/month up to enterprise volumes. Solid for validation and basic line-type work. Not an identity product, so don't expect owner names.

omkarcloud/phone-lookup-api (open source). A self-hostable REST API that returns carrier, line type, and E.164 details, with a free tier for kicking the tires (GitHub). Great for the reverse-phone-lookup-api-python and reverse-phone-lookup-api-javascript crowd who'd rather run their own thing than pay per call. The catch? No owner identity, and you maintain it yourself. Freedom has a price, and the price is your weekend.

Tier 3: US identity specialists

Service Objects (GeoPhone), Enformion, and Tracers. These lean hard into US identity data, name plus address on landlines, skip-tracing depth, the kind of records that power collections and investigations. Coverage is US-first and the tone is corporate. Pricing usually means "contact sales," which tells you who they're built for. Not a white pages reverse phone lookup api replacement for casual use, but strong where deep US person-data is the whole point.

What people actually ask about all this lives in the community threads. Search r/sales or r/msp and the recurring question is the same one you're asking: which reverse phone or bulk reverse phone lookup tool is worth paying for, and which free tier is a trap. The consensus, roughly? Carrier-sourced data beats prefix-guessing every time, and "free and unlimited" doesn't exist.

Pricing & Free Tiers Compared

Now the part that actually decides the purchase. Because here's the uncomfortable truth: two APIs can return the exact same line-type field, and one charges you multiples of the other for it.

Across the market, per-lookup pricing runs from about $0.004 to $0.025 per record, roughly $4 to $25 per 1,000 lookups, depending on depth (Reachly, 2026). Format and country checks sit at the cheap end. Carrier and line type in the middle. Real-time reachability and fraud scoring at the top. Same-ish data, very different bills.

Which brings up the single most useful piece of advice in this whole article: run Google's open-source libphonenumber as your free first layer. It handles format validation and country parsing at zero cost, using the same data Google runs internally. Only pay a provider for the stuff libphonenumber can't give you (carrier, line type, identity). A lot of teams skip this and overpay by a factor of ten. Don't be that team.

Is there a free reverse phone lookup api?

Sort of. Several providers offer a free reverse phone lookup api tier: Numverify hands you 100 requests a month, IPQS gives 1,000 lookups, omkarcloud's open-source repo covers a chunk for free, and libphonenumber is unlimited if you self-host format checks. But a truly unlimited, 100%-free, identity-grade lookup? Doesn't exist. The carrier and public-record data behind real answers costs money to license. Anyone promising otherwise is selling you stale data or your own privacy.

Accuracy & Coverage: What to Actually Check

That $19.90 CPC isn't a fluke. It's the market telling you accurate phone data is scarce and valuable. So before you sign anything, test it. Every vendor's landing page claims "99% accurate, global coverage." Ignore the page. Run a real check instead.

Pull 200 numbers you already know the answers for. Send them through two APIs. Score three things: how many good numbers get correctly flagged valid, how many dead numbers get correctly flagged dead, and how often the line-type label (mobile, landline, VoIP) is actually right. Half a day of work. It'll save you a year of paying for the wrong tool.

A few coverage realities worth knowing. US identity data is the strongest across Trestle, IPQS, and Twilio, because that's where the public-record and CNAM ecosystem is deepest. International reverse phone api coverage is patchier and varies a lot by country (Trestle's 100+ is unusually broad). Mobile and VoIP numbers are harder than landlines everywhere. And accuracy claims of "90%+" almost always mean 90%+ on US numbers, on a good day.

There's a deeper reason accuracy matters so much: contact data rots. B2B contact data decays around 30% per year, climbing toward 70% in fast-moving sectors like SaaS and tech, and poor data quality costs the average company roughly $15 million a year (MarketsandMarkets). A 10,000-contact file loses 2,500 to 3,000 usable records annually if nobody maintains it (Cleanlist). A phone number verified today might be dead by Q3. That's exactly why the freshness of the data source matters more than any accuracy badge.

If phone enrichment is one piece of a bigger data puzzle for you, it's worth understanding where reverse lookup sits next to broader data enrichment tools and stacked approaches like waterfall enrichment. They solve related but different problems, and knowing which is which saves budget.

Reverse Lookup vs Phone Validation API

Here's a distinction that'll save you money. You might not need to know who owns a number. You might just need to know if it's alive.

A phone validation api answers a narrow question: is this number correctly formatted, tied to a real carrier, and active? Format, country, carrier, line type, reachability. That's it. It doesn't tell you the owner's name, and for a huge number of use cases, it doesn't need to. Cleaning a signup form? Validation. Checking a list is dialable before a campaign? Validation. Deciding whether to send an SMS? Validation.

A reverse phone lookup api goes further and adds identity: name, address, demographics. That extra layer costs more and carries more compliance weight (you're now handling personal data, not just technical metadata). So the honest question to ask yourself is: do I need identity, or do I just need "is this number real?"

Plenty of tools blur the line and offer both. Twilio and Numverify skew validation. Trestle and the US specialists skew identity. IPQS straddles it with a fraud lens. Match the tool to the actual question, not to the fanciest feature list. Buying identity data when you only needed validation is like renting a moving truck to carry a backpack.

Getting Business Phone Numbers at Scale

Meet Marta. She's an SDR at a web agency, and her boss just handed her a target: 5,000 phone numbers for plumbers across Texas. Not "identify these numbers I already have." Find them. From nothing.

A reverse phone lookup api is useless to her. Every tool above starts with a number you already own. Marta owns zero. She has a category (plumbers) and a place (Texas), and she needs the numbers themselves. Different problem, different tool.

This is the gap Scrap.io fills, and it's worth being precise about it: Scrap.io is not a reverse lookup API. It doesn't turn a number into an owner's identity. It does the opposite and the complement. It builds the list of businesses in a category and a zone, straight from Google Maps, and hands you their phone numbers, emails, and social profiles at scale. Where a lookup API assumes you already have the number, Scrap.io is how you get it in the first place.

The scale is genuinely large: 225,676,406 businesses indexed, 195 countries, 4,000+ categories. Marta picks "plumber," picks "Texas," hits export. Done. And the smart part is the filtering, which runs before extraction. Only want listings that actually have a phone number present? Filter for it, and you never burn a credit on a business you can't call. Zero waste.

Need to target a specific trade area rather than a whole state? GeoSearch lets you draw a radius around a point, or hand-draw a polygon over an exact neighborhood or industrial zone. All the filters still apply inside it.

One honesty note, because overselling helps nobody. Scrap.io's native mobile/landline typing is not available in the US and Canada (blame number portability). So Marta's US play is clean: use Scrap.io to extract the numbers, then hand them to a line-type api like Twilio or libphonenumber to classify them. Outside the US and Canada, Scrap.io types numbers as fixed, mobile, or special natively, so that second step disappears. Two tools, one pipeline, no fantasy.

And it's not just a point-and-click interface. There's a REST API (300 requests/minute, included on every plan) plus an official MCP connector, so an AI agent like Claude or ChatGPT can build the search in plain language. "Find plumbers in Texas with a phone number" becomes a real export without you touching a filter. The full walkthrough on the sourcing side lives in our guide to scraping phone numbers from Google Maps, and the developer view is in the Google Maps Scraper API breakdown.

Once the numbers are in hand, you can push them straight into your stack. Scrap.io exports to CSV or Excel and connects through the API or Make.com, so you can auto-enrich your CRM with Google Maps data on autopilot.

Compliance: TCPA, DNC, GDPR & CCPA

The less fun part. But skip it and you'll wish you hadn't, because calling US numbers carelessly is how you meet the TCPA. And the TCPA does not send warnings.

In the US, the Telephone Consumer Protection Act draws a hard line between mobile and landline. Autodialed calls and marketing texts to cell phones need prior express consent, with exposure up to $1,500 per call if you get it wrong. Multiply that across an unclassified list and, yeah, the math gets ugly fast. This is exactly why line-type data isn't just a nice-to-have, it's a legal shield. Know which numbers are mobile before you dial or text.

Scrub every list against the National Do Not Call (DNC) Registry before each campaign. Not once. Every time. And if you're reaching EU prospects, GDPR treats phone numbers as personal data, so you need a lawful basis (legitimate interest works for B2B, but document it). California's CCPA carries similar rules, with a carve-out for publicly available business information.

That carve-out is worth noting on the sourcing side. Scrap.io only collects publicly available business data from Google Maps and business websites, which keeps things GDPR and CCPA compliant, and every record is traceable to its source. Once you've got clean, consented numbers, pair them with a solid script, our B2B cold calling scripts and the data behind cold calling success rates both help you actually convert the calls you're legally allowed to make.

How to Choose (and the Bottom Line)

Strip away the noise and the decision is simple. Ask what you're actually doing.

Need to identify who owns a US number? Trestle. Screening for fraud and spam? IPQS. Already on Twilio and just need line type? Twilio Lookup. Tight budget or building an MVP? Numverify, Abstract, or the open-source omkarcloud repo, with libphonenumber as your free first layer no matter what. And if your real problem is that you don't have the numbers yet? None of these. You need a sourcing tool, and that's where Scrap.io comes in.

That's the honest summary: reverse lookup to identify, Scrap.io to source. They're complementary, not competitors. Most teams doing serious outbound end up using both, one to build the list and one to enrich or verify it. Start on whichever side your gap is. If it's the "I have no numbers" side, that's the faster win.

FAQ

Is there a 100% free reverse phone lookup API?

Not a truly unlimited one. Several APIs offer free tiers, Numverify gives 100 requests a month, IPQS offers 1,000 lookups, and omkarcloud's open-source project covers a batch for free, plus Google's libphonenumber is free for format and country checks if you self-host. But an unlimited, identity-grade, always-free reverse phone lookup api doesn't exist, because the carrier and public-record data underneath costs money to license.

What's the difference between a reverse phone lookup API and a phone validation API?

A phone validation api tells you whether a number is valid and active: format, carrier, line type, reachability. A reverse phone lookup api adds identity on top: the owner's name, address, and demographics. Many providers combine both, but if you only need to know a number is real and dialable, validation is cheaper and carries less compliance weight than full identity lookup.

Can ChatGPT (or an AI agent) look up phone numbers?

Not reliably on its own. An AI model has no live phone database. But connect it to a source through a connector or MCP, and it can query real data in natural language. For example, Scrap.io's MCP connector lets Claude, ChatGPT, or Gemini search and pull business phone numbers by category and zone, without you touching a filter. The AI handles the request; the connector supplies the actual data.

How accurate is a reverse phone lookup API?

It varies. The leading providers claim 90%+ accuracy on US numbers, but accuracy drops on international numbers and on mobile or VoIP lines. Marketing pages always quote the best-case figure, so test any API on a sample of numbers you already know before you commit. Half a day of testing beats a year of paying for data that misses.

How do I get business phone numbers in bulk (not just identify one)?

A reverse phone lookup api won't help here, since every one of them starts with a number you already have. To build a list of numbers by industry and location, use a Google Maps extractor like Scrap.io: pick a category, pick a zone (up to an entire country), filter for listings that have a phone present, and export. It's the sourcing counterpart to a lookup API, you get the numbers first, then identify or verify them if you need to.