Hunter.io Email Verifier API: Add Real-Time Verification to Your Signup Forms

The Hunter io email verifier API lets you check an email address in real time, right from your signup form or backend, before it ever reaches your database. This guide explains how to get an API key, call the verify endpoint, read the JSON response, and wire real-time verification into signup forms and a CRM, with credit cost and rate limits covered.

What Is the Hunter.io Email Verifier API?

The Hunter.io email verifier API is a REST endpoint that verifies one email address on demand and returns a deliverability status, a confidence score, and risk flags as JSON. It lets developers verify at the point of capture instead of cleaning lists later in bulk. The endpoint lives at api.hunter.io/v2/email-verifier and accepts a GET request with the email and an API key.

The API moves verification upstream — from after-the-fact list cleaning to the exact moment a visitor types an address. That shift is what makes a signup form able to reject a junk email before it ever reaches the database.

What Can the Hunter Verifier API Do?

The API returns the same data as the dashboard verifier: a deliverability status, a numeric confidence score, and boolean flags for catch-all, disposable, webmail, and gibberish addresses. It supports single-address checks built for forms and can be scripted in a loop for batch runs, covering both real-time validation and programmatic cleaning from one key.

• Status and score: Every call returns a deliverability status alongside a confidence score from 0 to 100, giving precise control over whether a borderline address gets accepted, flagged, or rejected by form logic.
• Risk and type flags: Boolean fields mark disposable services, webmail providers, gibberish patterns, accept-all servers, and failed SMTP checks, so the response explains exactly why an address scored the way it did.
• Single and scripted runs: One request verifies one address for a live form, while a scripted loop over the same endpoint handles list cleaning, letting a single integration cover both capture-time and batch needs.
• JSON-first output: Results arrive as structured JSON that maps cleanly onto form decisions, CRM fields, and automation branches, removing any parsing guesswork for the developer wiring it in.
• Same engine as bulk: The endpoint runs the identical verification logic as the bulk uploader, so an address checked at signup gets the exact accuracy a later bulk pass would produce, only sooner.

The API exposes the full verification result programmatically — the same data the dashboard shows, delivered in real time to whatever code calls it.

How Do You Get a Hunter API Key?

Getting a key takes three steps: create a Hunter account, open the API section in account settings, and copy the secret key shown there. The free plan includes API access within its monthly credit limit, so the endpoint can be tested end to end before any paid tier is needed. The same key works for verification and finding calls.

1. Create an account: Sign up at Hunter with an email and password to provision a free workspace, which immediately includes API access and a starter monthly credit allowance for testing the verifier.
2. Open API settings: Navigate to the API section inside account settings, where Hunter displays the secret key, current usage, and the request limits attached to the active plan.
3. Copy the secret key: Copy the API key into an environment variable or secrets manager, never into client-side code, so the key stays server-side and out of public form markup.

An API key takes a minute and works on the free plan — enough credits to test real-time verification against the live endpoint before committing.

How Do You Authenticate the Hunter.io Email Verifier API?

Send a GET request to api.hunter.io/v2/email-verifier with the email and the API key as query parameters; it returns JSON containing status, score, and flags. Reading the status field is enough to decide whether to accept, reject, or flag the address. The shapes below show a minimal request and a trimmed response.

GET https://api.hunter.io/v2/email-verifier
  ?email=jane@example.com
  &api_key=YOUR_API_KEY

{
  "data": {
    "status": "valid",
    "score": 92,
    "regexp": true,
    "disposable": false,
    "webmail": false,
    "mx_records": true,
    "smtp_check": true,
    "accept_all": false,
    "block": false
  }
}

1. Build the request URL: Append the email and api_key query parameters to the email-verifier path, encoding the address so special characters survive transit to the endpoint without corrupting the lookup.
2. Send the request server-side: Issue the GET from the backend rather than the browser, keeping the secret key off the client so it never appears in public network traffic or page source.
3. Parse the JSON data object: Read the returned data object and extract the status and score fields, which together describe deliverability and confidence for the address that was just submitted.
4. Act on the status value: Branch on the status to accept valid addresses, reject invalid ones, and route accept-all or unknown results to a softer warning, turning one response into a clear decision.
5. Handle errors and limits: Catch non-200 responses and rate-limit headers so a failed lookup falls back to a soft warning rather than crashing the submission or silently dropping a legitimate signup.

One request, one JSON response — reading the status field is all the logic most signup forms ever need.

How Do You Add Real-Time Verification to a Signup Form?

On form submit, the backend calls the verify endpoint with the entered email, then allows, warns, or blocks based on the returned status. Invalid addresses get rejected with a friendly message, catch-all results get flagged for review, and clean valids proceed — stopping bad data before it reaches the database. The check runs server-side to protect the key.

1. Hook the form submit: Intercept submission on the server before the record is saved, passing the typed email to the verification step so no unchecked address ever reaches the user table.
2. Verify the input: Call the endpoint with the submitted address, then wait for the sub-second response that carries the status and score needed to judge the email at capture.
3. Accept valid addresses: Save records returning a valid status straight through, letting genuine users complete signup without friction or an extra confirmation step in the flow.
4. Block clear invalids: Reject addresses returning an invalid status with an inline error that asks the visitor to retype, stopping bounce-prone data before it enters the database.
5. Warn on ambiguous results: Surface a soft prompt on accept-all or unknown statuses so borderline addresses are double-checked rather than hard-blocked, protecting genuine users from a false rejection.

Verifying on submit blocks fake and mistyped emails at the door, which is the single highest-value use case for the API.

How Does the API Return and Score Results?

Each response includes a status (valid, invalid, accept_all, webmail, disposable, or unknown) and a numeric confidence score from 0 to 100. Form logic builds on both: accept high-confidence valids, reject invalids, and decide accept-all cases by score. The score is what makes borderline handling precise rather than a blunt pass-or-fail gate.

Source: Hunter API documentation, hunter.io/api-documentation/v2, verified 2026-06-27.

The verifier returns six status values and a score, with webmail and disposable addresses scored at fifty.

— Hunter API documentation

Status plus confidence score lets form logic handle the grey zone in the middle, not just a binary pass or fail.

API vs Bulk Verification: When Should You Use Each?

Use the API for real-time checks at the point of capture and bulk for cleaning existing lists. They are complements, not alternatives: the API keeps new data clean as it arrives, while bulk removes decay from the back catalog. Most mature setups run both from the same account and credit pool. The table below contrasts the two approaches.

Source: Hunter API documentation and pricing, hunter.io/api-documentation/v2 and hunter.io/pricing, verified 2026-06-27.

API for capture, bulk for cleanup — complements that share one credit pool, not rival products. For the foundations, see what email verification is.

What Are the API’s Rate Limits and Performance?

The verify endpoint responds in well under a second, fast enough for live forms, and is rate limited to 10 requests per second and 300 per minute. For high-traffic forms, cache repeat results and handle the unknown status gracefully so a slow or capped upstream never blocks a genuine signup from completing.

• Response speed: A single verification returns in roughly a second or less, quick enough to run inline on form submit without leaving a visitor staring at a frozen button.
• Per-second cap: Hunter limits the endpoint to 10 requests per second, comfortably above the rate a normal signup form generates from organic and paid traffic combined.
• Per-minute cap: A 300-requests-per-minute ceiling sets the sustained budget, which spike-heavy public forms should respect with a short queue rather than firing every submit instantly.
• Caching repeats: Storing recent verdicts for addresses already checked trims duplicate calls, keeping a busy form well inside the limits while cutting credit spend on retries.
• Graceful fallback: Treating unknown and timeout cases as a soft warning rather than a hard block keeps the form usable when the upstream is slow, protecting conversion alongside data quality.

Sub-second responses suit live forms — the one rule is to handle unknown gracefully so verification never blocks a real signup.

What Can You Integrate the Verifier API With?

The API plugs into web forms, CRMs, and automation tools such as Zapier, so verified status travels with the contact downstream. Common integrations verify at signup, before CRM record creation, and inside lead-routing flows. The table lists typical integration points and what each one protects against.

Source: Hunter API documentation, hunter.io/api-documentation/v2, verified 2026-06-27.

Verifying every address before it lands in the database is the cheapest way to keep bounce rates low.

— Growth Hack Suite, reduce email bounce rate with Hunter.io

Integrations carry verified status downstream, so clean data enters the CRM and automation flows, not just the form field.

How Much Does the Verifier API Cost?

API verifications draw from the same credit pool as the dashboard, where the free plan includes 50 credits per month and each verification costs half a credit, so roughly 100 verifications are free monthly. Paid plans scale credits, with verification working out near $7.45 per 1,000 on the Growth tier. Budget by expected signup volume, since the API carries no separate fee.

• Free plan credits: Hunter includes 50 credits per month on the free plan, renewing each billing cycle so testing the API never expires after a one-time allowance.
• Cost per verification: Each verification draws half a credit, which turns the monthly free allowance into roughly 100 verifications before any paid upgrade becomes necessary.
• Verification on the Growth tier: Paid credits scale the same pool, with verification working out near $7.45 per 1,000 addresses and no separate API charge layered on top.

Source: hunter.io/pricing, verified 2026-06-27.

API cost equals bulk per verification, so the right move is to budget by signup volume rather than expect a separate API fee.

Is the Hunter Verifier API Worth Integrating?

For any product collecting emails through forms, the answer is yes: blocking fake and mistyped addresses at entry is cheaper than cleaning them in bulk later and protects database quality continuously. Low-traffic sites with rare signups may not need it, which is an honest exception — for them, an occasional bulk pass covers the same ground at less effort.

• Worth it for: Products with steady form signups, CRM-fed sales motions, or paid acquisition where every fake address wastes spend benefit most, since the API stops junk data at the source instead of after it accumulates.
• Skip if: A brochure site with a handful of signups a month gains little from integration work, and an occasional bulk upload achieves comparable list quality without writing or maintaining any verification code.

For form-driven products the API pays for itself quickly; for rare signups, bulk alone may genuinely suffice. The wider Hunter vs ZeroBounce comparison shows where each tool fits.

Verdict: Should You Use the Hunter Verifier API?

For products collecting emails continuously, the Hunter verifier API is worth integrating: a sub-second check at signup keeps the database clean at the source, runs on the free tier for testing, and pairs with bulk for the back catalog. Set it up once and bad data stops at the door. For accuracy detail, see the Hunter Email Verifier accuracy benchmark.

Email verification confirms an address exists and can receive messages.

— Wikipedia, Email verification

The Real-Time Verification Flow in Three Numbers

The whole integration reduces to three figures: one API call per signup, a sub-second response, and a confidence score from 0 to 100 that drives the accept-or-block decision. The cards below capture the flow that turns a typed address into a clean database record.

One call, one fast response, one score — that is the entire real-time verification loop a signup form runs on every submit.

Related Tools in the Hunter Stack

The API handles capture-time verification, while the dashboard and bulk uploader handle existing lists. The Hunter verifier review covers the full product, and the email finder covers the other half of the same credit pool.

• Hunter Email Verifier: The validation product behind this API, including how it works and what each flag means — start with what the Hunter Email Verifier is.
• Hunter Email Finder: The other half of the bundle that shares the same credit pool — read the Hunter.io email finder review for sourcing costs.

Hunter Email Verifier API: Frequently Asked Questions