NeverBounce API Review: Complete 2026 Breakdown

The question behind every email verification API is whether it does enough. Not whether it validates addresses (they all claim to), but whether the authentication model is open, the rate limits are workable, the SDKs cover your stack, and the pricing scales without surprises.

NeverBounce's REST API has been the standard verification API for developers building email checks into pipelines, forms, and CRM workflows since 2014. Seven official SDKs, a JavaScript Widget for client-side form validation, and credit-based pricing starting at $0.008 per email make it easy to get running. Backed by ZoomInfo Technologies since 2019, the platform processes billions of verifications monthly across 150,000+ businesses.

But validation and intelligence are different layers.

NeverBounce's API does one thing: verify whether an email address is deliverable. Single-check verification for point-of-entry validation, and bulk jobs for existing lists. It tells you whether an address is valid, invalid, disposable, catch-all, or unknown. It does not tell you who owns that address, what company they work for, what technology that company runs, whether the account is researching your category, or where the contact sits in an org chart. That is a different category, and NeverBounce's API was never designed to cover it.

This is where ZoomInfo enters the picture. A B2B intelligence platform built on 500M contacts and 100M companies, ZoomInfo's Enterprise API covers search, enrichment, AI intelligence, and audience management, with OAuth 2.0 authentication and an MCP server for AI-agent workflows. NeverBounce verifies emails you already have; ZoomInfo provides the B2B intelligence behind those emails.

This review covers the NeverBounce API in full technical depth first, then examines ZoomInfo's API as the layer that picks up where email verification stops.

NeverBounce API at a Glance

NeverBounce API: What Works Well & What to Plan Around

NeverBounce API: Authentication & Getting Started

Getting API access is straightforward. Create a free NeverBounce account, navigate to the Apps tab, and create a Custom Integration App to generate an API key. Every new account receives 10 free credits usable via the API, enough to test both single and bulk verification.

Authentication uses an API key passed as a parameter in each request. No OAuth flow, no token exchange, no token refresh cycle. You include key={api_key} in the request body or query string, and the API authenticates the call.

Starting with API v4, accounts can hold multiple API keys by creating multiple Custom Integration Apps, allowing per-integration reporting and settings management.

A basic single-check request:

curl "https://api.neverbounce.com/v4.2/single/check?key=YOUR_API_KEY&email=test@example.com&timeout=10"

Two things to know about credential handling:

• Never use the standard API key in client-side code (browsers), because doing so exposes the credential. The JavaScript Widget exists for that use case, using a public key scoped to authorized domains with throttling to prevent abuse.

Source: NeverBounce

• NeverBounce separates server-side API access (Custom Integration with private key) from client-side form validation (JavaScript Widget with domain-scoped public key), so credentials never appear in browser contexts.

Beyond the 10 free credits, verification consumes purchased credits from the same pool the dashboard uses. There is no developer-only free tier. Accounts without a saved payment method face rate limiting and restricted bulk access; adding a payment method removes these restrictions.

NeverBounce API: Core Endpoints & Capabilities

The API covers two use cases: real-time single-email verification and asynchronous bulk list verification. Both run from the same base URL at https://api.neverbounce.com/v4.2/.

Single Verification: /single/check

The /single/check endpoint verifies one email address in real time. It is designed for point-of-entry validation: form submissions, button clicks, checkout flows. Key parameters:

• email (required): the address to verify

• timeout: maximum seconds before returning unknown

• address_info: request additional address metadata

• credits_info: include account credit balance in the response

The response returns a result field with one of five result codes:

The response also includes a flags array with metadata: free_email_host, role_account, spamtrap_network, spelling_mistake, disposable_email, bad_syntax, and others. A suggested_correction field catches common typos (e.g., gmial.com to gmail.com), and diagnostic flags like has_dns and has_dns_mx expose infrastructure-level detail beyond the top-level result code.

The documentation recommends a 10-second client-side timeout and treating timeout responses as unknown.

What you would build with this: a registration flow that checks email addresses at signup, blocking disposable and invalid addresses before they enter your database, and suggesting corrections for typos.

Bulk Verification: Jobs API

The Jobs API handles existing contact lists asynchronously through a four-step pipeline:

1. Create (POST /jobs/create): Submit a list as a remote CSV URL (HTTP, HTTPS, or FTP with optional Basic Auth) or as inline data (array of arrays or array of objects). Maximum inline payload is 25 MB. Key parameters include auto_parse, auto_start, run_sample (for a free bounce-rate analysis before consuming credits), and callback_url for webhook delivery.

Source: NeverBounce

2. Status (GET /jobs/status): Poll for completion. The response includes job_status, percent_complete, and result counts: total_valid, total_invalid, total_catchall, total_disposable, total_unknown, and bounce_estimate.

3. Download (GET /jobs/download): Retrieve results as a CSV with result codes appended as the last column.

4. Results (GET /jobs/results): Alternative endpoint returning structured JSON results.

Supporting endpoints include /jobs/parse (manually trigger indexing) and /jobs/start (manually trigger verification after parsing).

What you would build with this: a nightly pipeline that pulls new CRM contacts, submits them as a bulk job, polls for completion (or listens via callback), then routes valid contacts to your sequencing tool and flags invalid records for cleanup.

NeverBounce API: Webhooks & Events

NeverBounce calls its webhook system Job Callbacks, introduced in API v4.2. You configure callbacks per job at creation time by passing a callback_url parameter (a URL your server exposes to receive POST requests). Custom HTTP headers can be supplied via callback_headers.

Callbacks arrive as POST requests with a JSON body:

{"job_id": 4920062, "event": "job_run_finished"}

Supported events:

Two constraints worth noting:

• Job Callbacks apply only to bulk verification jobs. There is no webhook for single/real-time verification events.

• The documentation does not describe a retry policy or delivery guarantee. If your callback URL is unreachable when NeverBounce sends the event, the documentation does not specify whether the delivery is retried or dropped.

For workflows that depend on guaranteed event delivery, you will need either a polling fallback (using /jobs/status) or your own reliability layer on top of the callback mechanism.

NeverBounce API: SDKs, Docs & Rate Limits

SDKs & Libraries

NeverBounce publishes seven official API wrappers on GitHub under the NeverBounce organization:

• Node.js: NeverBounceApi-NodeJS, installable via npm install neverbounce --save. The docs describe a rewritten TypeScript version (v5.0.0) requiring Node.js 18+, built with ES Modules and the Fetch API. Server-side use only.

• PHP: NeverBounceAPI-PHP

• Ruby: NeverBounceApi-Ruby

• Python: NeverBounceApi-Python

• Go: NeverBounceApi-Go

• .NET: NeverBounceApi-DotNet

• Java: NeverBounceApi-Java

Seven languages covers most stacks for a single-purpose verification API. The Node.js SDK is the only one with detailed release notes in the current documentation; maintenance status for the remaining six is not stated. No third-party community libraries are listed.

The JavaScript Widget is a separate, browser-safe tool for client-side form validation. It auto-detects type="email" input fields, verifies addresses as the user types (600ms debounce), and blocks disposable and invalid submissions by default. Configuration options include blocking freemail addresses, role-based accounts, and throttled attempts, plus custom accept/reject status codes and feedback messaging.

Documentation & Developer Experience

The developer documentation at developers.neverbounce.com is hosted on the ReadMe platform and organized into three sections:

• Guides: quickstart walkthroughs for API setup, single verification, list verification, free analysis, and the JavaScript Widget

• Interactive API Reference: endpoint-level documentation with a "Try It!" live explorer per endpoint, supporting Shell, PHP, JavaScript, Python, and Go code examples

• Changelog: version history from v3 through v4.2

An OpenAPI/llms.txt index is available, providing all pages in Markdown and endpoints in OpenAPI format. The docs include practical edge-case guidance (e.g., recommending a 10-second client-side timeout and treating timeouts as unknown).

Source: NeverBounce

Developer support is via email. No public developer Slack, community forum, or dedicated support channel exists. The changelog shows no recent updates to the v4.2 documentation, suggesting a stable but infrequently evolving API.

The documentation is adequate for the API's scope. The interactive reference is the fastest path to confirming request and response shapes, and the guides cover common integration patterns clearly. What is missing: no Postman collection, and the SDK documentation beyond Node.js is thin.

Rate Limits & Constraints

From the official Usage Guidelines:

Bulk verification:

• Maximum 10 concurrent jobs per account

• Maximum 50 job runs per day

• No more than 10 jobs per 100K items per hour (accounts may be locked if violated)

• Maximum inline payload: 25 MB per /jobs/create request

Single verification:

• Must only be used for real-time, user-triggered checks (form submissions, button clicks). Using it to iterate through a list is prohibited and may result in account lock and API access suspension.

Payment-gated access: Accounts without a default payment method face rate limiting and restricted bulk API access.

You can request exceptions to the bulk usage limits by contacting NeverBounce directly.

The 10-concurrent-job limit is the constraint most developers hit first. If you run multiple bulk jobs in parallel (e.g., processing lists from different CRM segments at once), you will need to queue jobs on your side. The 50-jobs-per-day limit caps how many distinct list verification runs you can trigger in a 24-hour window.

NeverBounce API Pricing & Access Costs

NeverBounce uses a credit-based model: 1 credit = 1 email verification. Credits are shared across dashboard and API usage. There is no separate API pricing tier; the API draws from the same credit pool as the dashboard.

Pay-as-you-go

• $8 per 1,000 credits ($0.008 per email) at the base tier

• Volume pricing scales down: approximately $0.003 per email at 1,000,000 emails

• Buying in larger batches costs less (the docs note that purchasing 50,000 credits in one batch versus ten batches of 5,000 saves approximately 37%)

• Credits expire 365 days after purchase

• No monthly commitment

Growth Plan ($49/month)

• Up to 10,000 emails/month included

• Auto-sync with CRM: only new, unique emails consume credits; duplicates are free

• Unlimited parallel list cleaning

• A sliding-scale pricing calculator applies at higher volumes

• Annual billing available with approximately 20% discount

• Legacy pay-as-you-go credits carry over and stack on top of the monthly allotment

Enterprise (Custom Pricing)

• Typically applies at 250,000+ emails/month

• Dedicated account manager, custom GTM Guard configuration, advanced security and compliance

• Manual invoicing available

What to Watch For

• Every new account receives 10 free credits on registration, usable via the API. Once exhausted, accounts with a saved card are charged at standard rates. No ongoing free tier exists.

• With auto-upgrade enabled on the Growth plan, exceeding the monthly credit allotment triggers an automatic tier upgrade and an immediate charge.

• Credits cannot be refunded once purchased or used.

For a developer building a pipeline that verifies 100,000 emails per month, the effective cost on pay-as-you-go is approximately $400-500/month, depending on how credits are purchased.

Where the NeverBounce API Falls Short

These are scope decisions and practical constraints a developer should plan around.

Email verification is the entire scope. The NeverBounce API verifies whether an email address is deliverable. It does not return who owns that address, what company they work for, their job title, their phone number, the company's tech stack, or any buying intent signals. If your pipeline needs to answer "is this email valid AND who is this person," the API covers half that question.

Source: NeverBounce

Single-check cannot be used for batch processing. The Usage Guidelines prohibit using /single/check to iterate through a list. Doing so may result in account lock and API access suspension. You must use the asynchronous Jobs API for any batch workflow, even if you would prefer the simplicity of sequential single-check calls.

Bulk job limits constrain throughput. Ten concurrent jobs and 50 job runs per day set hard ceilings on parallel processing. A pipeline that verifies multiple list segments at once (e.g., different CRM segments, different lead sources) will need its own job queue.

No OAuth or scoped tokens. Authentication is a single API key passed as a parameter. No OAuth flow, no scoped tokens, no documented key rotation mechanism. Teams that need granular access control (e.g., different permissions for different services) must create multiple Custom Integration Apps, each with its own key.

Webhook delivery is not guaranteed. Job Callbacks do not document retry behavior or delivery guarantees. If your callback endpoint is down when NeverBounce sends the event, the documentation does not specify what happens next. Event-driven architectures will need a polling fallback.

Catch-all domains remain unresolvable. Domains configured to accept all incoming mail return a catchall status that cannot be resolved to valid or invalid. This is a category-wide limitation (not specific to NeverBounce), but it means a meaningful percentage of B2B email addresses (particularly at small businesses, government, and educational organizations) will return an ambiguous result.

SDK maintenance is unclear. Seven official SDKs exist, but only the Node.js SDK has detailed version documentation. The maintenance state of the PHP, Ruby, Python, Go, .NET, and Java wrappers is not stated in the official docs.

No B2B intelligence data. NeverBounce tells you if an address bounces. It does not tell you whether the person behind that address is a decision-maker, whether their company is in-market, what technology they use, or where they sit in the org chart. If your build needs that layer, it needs a different API.

ZoomInfo API: The B2B Intelligence Layer NeverBounce Does Not Cover

NeverBounce answers one question: is this email deliverable?

ZoomInfo's API answers the questions that come next: who is this person, what company do they work for, what does that company look like, and are they researching solutions in your category?

Source: ZoomInfo

The two APIs operate at different layers. NeverBounce validates addresses you already have. ZoomInfo provides verified contact data (including 300M+ verified business email addresses) alongside the intelligence you need to act on those contacts: company context, technographics, org charts, intent signals, and AI-driven account research. Behind that intelligence is the GTM Context Graph, which processes 1.5B+ data points daily by combining ZoomInfo's B2B data with your first-party data.

What the API Covers: Search, Enrichment, and AI Intelligence

ZoomInfo's Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into four groups documented in the interactive API reference:

Data API (Search and Enrich): The primary group. Search endpoints cover Contacts, Companies, Intent, News, and Scoops, returning matched records without consuming credits. Enrich endpoints return full records: business emails, direct dials, employment history, corporate hierarchy, org charts, technographics, and hashtag signals, accepting up to 25 records per call. The search-then-enrich pattern means you filter freely, then pay only for the records you commit to. The underlying dataset spans 500M contacts, 100M companies, 135M+ verified phone numbers, and 300M+ verified business email addresses.

Source: ZoomInfo

AI Intelligence API (GTM Workspace): A separate API group that exposes GTM Workspace AI features programmatically. Account Summary returns structured account intelligence with a free-form Q&A endpoint. Find Similar Companies performs lookalike expansion from a seed account. Contact Recommendations returns AI-ranked buying-committee suggestions by motion (prospecting, deal acceleration, renewals).

Marketing API: CRUD endpoints for audience management.

The pairing with a verification API is direct: a developer could use NeverBounce to verify emails collected from forms and third-party lists, then call ZoomInfo's Enrich endpoint to append company data, org charts, technographics, and intent signals to those verified contacts, either through a downstream enrichment step or as a parallel pipeline.

Authentication, Rate Limits & Credits

Authentication uses OAuth 2.0 with PKCE via Okta, issuing access tokens with rotating refresh tokens. Three flows are supported: Authorization Code with PKCE (for web applications), Client Credentials (for server-to-server), and Refresh Token. Teams register applications through the ZoomInfo Developer Portal, where they generate credentials, define scopes, and test endpoints.

Rate limits are published by tier: Builder (5 req/sec), Standard (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced simultaneously. Every response includes quota headers with remaining capacity, and 429 responses include a Retry-After header with exact backoff timing. Credits follow a rolling 12-month window: enriching a record for the first time consumes one credit; re-enriching the same record within the year is free.

Source: ZoomInfo

Webhooks, MCP & Developer Experience

Webhooks are available via the Agents API, tied to ZoomInfo's Agent Teams system. Event types cover bulk enrichment jobs completing, records changing, credit usage crossing thresholds, and new GTM signals (scoops, funding events, intent spikes) becoming available, with retry behavior and throttling configurable per event type.

For developers building AI agents, ZoomInfo's MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account research as native tools for MCP-compatible assistants, currently supporting Claude and ChatGPT. A developer building an AI agent could connect the MCP server for contact and company intelligence, then call NeverBounce for verification of addresses from outside ZoomInfo's database.

Source: ZoomInfo

ZoomInfo does not publish official SDKs, so you integrate over HTTP and own the auth-and-retry layer. The interactive API reference supports live testing, and a Docs MCP server lets AI development tools generate integration code against the API spec. Documentation is at docs.zoominfo.com. ZoomInfo added API access to all relevant plans in 2025 with consumption-based pricing.

BDO Canada reported an 87% reduction in time spent on updates to internal data dashboards using the ZoomInfo API, with one analyst describing the integration as plug-and-play across any process. (ZoomInfo)

Final Verdict

NeverBounce's API does email verification well. The REST API is simple, the authentication is straightforward (API key, no OAuth ceremony), the SDKs cover seven languages, and credit-based pricing starts at under a penny per email. The JavaScript Widget gives non-backend teams a way to add form validation without server-side code. For the job of checking whether an email address will bounce, the API is well-scoped.

Choose the NeverBounce API if you have email addresses from forms, CRM imports, or third-party lists and need to verify their deliverability before sending. The single-check endpoint handles point-of-entry validation, the Jobs API handles bulk lists, and the pricing is transparent enough to model costs before you build.

Choose the ZoomInfo API when your pipeline needs more than a valid/invalid answer: who owns that email, what company they represent, what technology that company runs, and whether the account is in-market. ZoomInfo's search-then-enrich pattern covers the B2B intelligence that NeverBounce was never designed to address, and the AI Intelligence API adds account research and contact recommendations that no verification API provides. Together, the two APIs cover both verification and intelligence. Start with the ZoomInfo Enterprise API or explore the developer docs to see the endpoints directly.

A developer who only needs to check bounce risk and has no need for contact enrichment, company intelligence, or intent data should build on NeverBounce's API. It is honest about its scope, and that scope is exactly right for the verification layer.

FAQ

Is the NeverBounce API free?

Not beyond an initial trial. Every new account receives 10 free credits on registration, usable via the API for both single and bulk verification. After those 10 credits are consumed, all verification requires purchased credits at pay-as-you-go rates starting at $0.008 per email ($8 per 1,000 credits). There is no ongoing free tier. Accounts without a saved payment method face rate limiting and restricted bulk API access. Every list upload does include a free instant bounce analysis before any credits are consumed.

Does NeverBounce have a GraphQL API?

No. NeverBounce exposes a REST API that returns JSON. The current version is v4.2, served from api.neverbounce.com/v4.2/. There is no GraphQL endpoint.

What is the NeverBounce API rate limit?

The documented limits apply to bulk verification: a maximum of 10 concurrent jobs, 50 job runs per day, and no more than 10 jobs per 100,000 items per hour. The single-check endpoint does not publish a requests-per-second limit but is restricted to real-time, user-triggered use; sequential list iteration is prohibited and may result in account lock. You can request exceptions to the bulk limits by contacting NeverBounce directly.

Are there official NeverBounce SDKs?

Yes. NeverBounce publishes seven official API wrappers on GitHub: Node.js, PHP, Ruby, Python, Go, .NET, and Java. The Node.js SDK (v5.0.0) is the most recently documented, rewritten in TypeScript with ES Module support and requiring Node.js 18+. A JavaScript Widget is also available for client-side form validation without exposing server-side credentials. All wrappers are hosted under the NeverBounce GitHub organization.

Does the NeverBounce API support webhooks?

Yes, through Job Callbacks introduced in API v4.2. You configure callbacks per bulk job at creation time by passing a callback URL. NeverBounce sends POST requests for events including job parsing, verification start/finish, stats updates, sample analysis, manual review completion, and job failure. Callbacks apply to bulk jobs only; there is no webhook for single-check verification events. Retry policy and delivery guarantees are not documented.

What does ZoomInfo's API add to a NeverBounce build?

ZoomInfo's API adds the B2B intelligence layer that NeverBounce does not cover. NeverBounce verifies whether an email address is deliverable; ZoomInfo provides the identity and company intelligence behind those addresses. A developer can use ZoomInfo's search endpoints to find contacts matching an ICP, enrich them with direct dials, business emails, org charts, technographics, and intent signals, then use NeverBounce to verify emails collected from other sources outside ZoomInfo's database. The two APIs use different authentication models (API key vs. OAuth 2.0) and different pricing structures (per-credit vs. annual bulk credits), so plan the integration layer accordingly. ZoomInfo's MCP server extends the same data to AI-agent workflows, adding a programmatic intelligence layer that a verification API does not offer.