Email Verification API

6 Lines of Code. Sub-1.2s Response. Done.

Verify emails in real time at signup, block disposable addresses, catch typos before they enter your database. REST API. JSON response. SDKs for every major language.

100 free credits/day. No credit card. Credits never expire.

curl | Single Email Verification
# Verify a single email, get a single response

curl -X GET "https://api.quickemailverification.com/v1/verify \
  ?email=test@example.com \
  &apikey=YOUR_API_KEY"

# Response (147ms)
{
  "result": "valid",
  "reason": "accepted_email",
  "disposable": false,
  "accept_all": false,
  "role": false,
  "free": false,
  "email": test@example.com,
  "user": test,
  "domain": example.com,
  "mx_record": "mx.example.com",
  "mx_domain": "example.com",
  "safe_to_send": true,
  "did_you_mean": "",
  "success": true,
  "message": ""
}

Trusted by over 300,000 businesses of all size.

ISO 27001 Certified
ISO 27001
Certified
GDPR Compliant
GDPR
Compliant
CCPA Compliant
CCPA
Compliant
HIPAA Compliant
HIPAA
Compliant
99% Accuracy Guaranteed
99% Accuracy
Guaranteed

Try It Right Now. No Signup Required.

Verify a real email address or test with simulated sandbox responses. See exactly what the API returns.

Real-time verification using the production API. Results are actual, not simulated.

3 of 3 free tests remaining today
// Enter an email address and click "Verify" to see a real API response

Every Response Tells You More Than Valid or Invalid

Each API call returns 15 fields. Not just "valid," but whether it's safe to send, disposable, a role account, a catch-all, and if the user made a typo.

safe_to_send

Goes beyond "valid." Tells you if this email is actually safe to include in your campaigns. Filters out false positives that other tools mark as valid.

did_you_mean

Catches typos automatically. If a user types "john@gmial.com," the API suggests "john@gmail.com." Recover signups instead of rejecting them.

disposable

Detects temporary/throwaway email addresses. Block fake signups from services like Mailinator, Guerrilla Mail, and 10MinuteMail before they enter your database.

role

Identifies role-based addresses like info@, sales@, support@. These aren't tied to individuals and often have low engagement or trigger spam complaints.

accept_all

Flags catch-all domains that accept any email, even non-existent ones. These are "valid" but risky. Sending to them can damage your sender reputation.

free

Identifies free email providers (Gmail, Yahoo, Hotmail). Useful for B2B products that need to prioritize work email addresses over personal ones.

SDKs for Every Major Language

Copy-paste integration. Ready-to-use libraries with full documentation.

# Single email verification
curl --get --include \
  --url "https://api.quickemailverification.com/v1/verify \
    ?email=test@example.com \
    &apikey=YOUR_API_KEY"
// Install: composer require quickemailverification/quickemailverification
require_once 'vendor/autoload.php';

// Replace YOUR_API_KEY with your API Key
$client = new QuickEmailVerification\Client('YOUR_API_KEY');
$quickemailverification = $client->quickemailverification();

// Replace test@example.com with the email you want to verify
$response = $quickemailverification->verify('test@example.com');
// Install: npm install quickemailverification
var QuickEmailVerification = require('quickemailverification');

// Replace YOUR_API_KEY with your API Key
var client = QuickEmailVerification.client('YOUR_API_KEY').quickemailverification();

// Email address which need to be verified
client.verify('test@example.com', function(err, response) {
  // Print response object
  console.log(response.body);
});
# Install: pip install quickemailverification
import quickemailverification

// Replace YOUR_API_KEY with your API Key
client = quickemailverification.Client('YOUR_API_KEY')

quickemailverification = client.quickemailverification()

// Email address which need to be verified
response = quickemailverification.verify('test@example.com') 
print(response.body) # The response is in the body attribute
# Install: gem install quickemailverification
require "quickemailverification"

// Email address which need to be verified
client = QuickEmailVerification::Client.new('YOUR_API_KEY')

quickemailverification = client.quickemailverification()

// Email address which need to be verified
response = quickemailverification.verify('test@example.com')

puts response.body # The response is in the body attribute
// Install: go get github.com/quickemailverification/quickemailverification-go
import "github.com/quickemailverification/quickemailverification-go"

// Replace YOUR_API_KEY with your API Key
qev := quickemailverification.CreateClient("YOUR_API_KEY")

// Email address which need to be verified
response, err := qev.Verify("test@example.com")

if err != nil {
    panic(err)
 }

print(response.Result)
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;

public class QevSingleAPI {
  public static void main(String[] args) throws Exception {

      QevSingleAPI http = new QevSingleAPI();
      http.sendGet();
  }

  // HTTP GET request
  private void sendGet() throws Exception {
      String API_KEY = "API_KEY"; // Replace API_KEY with your API Key
      String EMAIL = "richard@quickemailverification.com"; // Email address which need to be verified

      String url = "https://api.quickemailverification.com/v1/verify?email="+EMAIL+"&apikey="+API_KEY;

      URL obj = new URL(url);
      HttpURLConnection con = (HttpURLConnection) obj.openConnection();

      // optional default is GET
      con.setRequestMethod("GET");

      int responseCode = con.getResponseCode();
      System.out.println("\nSending 'GET' request to URL : " + url);
      System.out.println("Response Code : " + responseCode);

      BufferedReader in = new BufferedReader(
              new InputStreamReader(con.getInputStream()));
      String inputLine;
      StringBuffer response = new StringBuffer();

      while ((inputLine = in.readLine()) != null) {
          response.append(inputLine);
      }
      in.close();

      //print result
      System.out.println(response.toString());
  }
}
using System;
using System.Web;
using System.Net;
using System.IO;

namespace QevSingleAPI
{
  class QevSingleAPI
  {
      static void Main()
      {
          try {
              string apiKey = "API_KEY"; // Replace API_KEY with your API Key
              string emailToValidate = "richard@quickemailverification.com"; // Email address which need to be verified
              string responseString = "";
              string apiURL = "https://api.quickemailverification.com/v1/verify?email=" + HttpUtility.UrlEncode(emailToValidate) + "&apikey=" +  apiKey;

              HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiURL);
              request.Method = "GET";

              using (WebResponse response = request.GetResponse()) {
                  using (StreamReader ostream = new StreamReader(response.GetResponseStream())) {
                      responseString = ostream.ReadToEnd();
                  }
              }
          } catch (Exception ex) {
          //Catch Exception - All errors will be shown here - if there are issues with the API
          }
      }
  }
}
Imports System.Net
Imports System.IO

Module QevSingleAPI
Sub Main()
  Try
      Dim apiKey as string = "API_KEY" ' Replace API_KEY with your API Key
      Dim emailToVerify as string = "richard@quickemailverification.com" ' Email address which need to be verified
      Dim responseString as string = ""
      Dim apiURL as string = "https://api.quickemailverification.com/v1/verify?email=" & System.Web.HttpUtility.UrlEncode(emailToVerify) & "&apikey=" &  apiKey

      Dim request As HttpWebRequest = DirectCast(WebRequest.Create(apiURL), HttpWebRequest)
      request.Method = "GET"

      Using response As WebResponse = request.GetResponse()
          Using ostream As New StreamReader(response.GetResponseStream())
              responseString = ostream.ReadToEnd()
              Console.WriteLine(responseString)
          End Using
      End Using
  Catch ex as exception
      ' Catch Exception - All errors will be shown here - if there are issues with the API
      Console.WriteLine(ex)
  End Try
End Sub
End Module
            

What Developers Build With This API

Real-time verification at the point of entry. Block bad data before it enters your system.

Signup Form Verification

Verify emails inline as users type. Catch typos, block disposable addresses, reject invalid emails before the form submits.

Fraud Prevention

Stop fake trial accounts, referral abuse, and bot signups. 33% of freemium accounts use disposable emails. Catch them at the door.

Checkout & Billing

Ensure transaction emails reach real inboxes. Verify billing email at checkout so order confirmations, receipts, and shipping updates land.

Lead Qualification

Score inbound leads by email quality. Free email vs. work email. Disposable vs. permanent. Save your sales team time on fake leads.

Newsletter & Subscription

Accept only valid, real emails at subscription. Maintain list hygiene from day one instead of cleaning later.

CRM & Database Hygiene

Clean existing records via batch API. Upload lists programmatically, get results with download URLs for safe, valid, invalid, and unknown categories.

Batch Verification API

Verify Email Lists Programmatically

Upload email lists via API, poll for completion, and download categorized results. Automate your entire list cleaning workflow without touching the dashboard.

Upload : POST your CSV via multipart/form-data with optional callback URL
Poll : Check job status with progress percentage until completion
Download : Separate URLs for SafeToSend, valid, invalid, unknown, and full report
Callback : Get notified via webhook when verification completes. No polling needed.
Batch API | Job Status Response
{
  "id": "7138f61de8da380c345374c08bd64599",
  "filename": "email_list.csv",
  "status": "completed",
  "created_date": "2017-08-18T04:06:08.000Z",
  "started_date": "2017-08-18T04:06:08.000Z",
  "completed_date": "2017-08-18T04:06:45.000Z",
  "processing_time": 37,
  "stats": {
    "total_email": 100,
    "progress": "100%",
    "result_counts": {
      "safetosend": 68,
      "valid": 82,
      "invalid": 16,
      "unknown": 2
    }
  },
  "download_urls": {
    "safetosend": "https://api.quickemailverification.com/...safetosend/...",
    "valid": "https://api.quickemailverification.com/...valid/...",
    "invalid": "https://api.quickemailverification.com/...invalid/...",
    "fullreport": "https://api.quickemailverification.com/...fullreport/..."
  },
  "success": "true",
  "message": ""
}

Why Developers Choose QuickEmailVerification

10/10

Ease of Setup on G2

Highest in the category. Verified on G2.

<1.2s

Average Response Time

Fast enough for real-time form validation.

100

Free Credits / Day

No credit card required. Credits never expire.

30B+

Emails Verified

Since 2014. Infrastructure built for scale.

$0

Charge for Unknown Results

You only pay for emails we can determine.

REST

Simple REST + JSON

No SOAP. No XML. No 40-page integration guide.

API Reference: Quick Glance

Endpoint Method Purpose
/v1/verify GET Verify a single email address in real time
/v1/verify/sandbox GET Test with simulated results, free, no credits deducted
/v1/bulk-verify POST Upload an email list for batch verification
/v1/bulk-verify/status/{id} GET Check job status and get download URLs
/v1/bulk-verify/delete/{id} DELETE Delete an email verification job

HTTP Status Codes

200 Success
400 Bad Request
401 Unauthorized
402 Low Credits
403 Disabled
404 Not Found
429 Rate Limited
500 Server Error

Common Questions About the Email Verification API

What is the difference between "valid" and "safe_to_send"?

A "valid" result means the email address exists and the mailbox can receive messages. But "valid" doesn't mean it's risk-free. Catch-all addresses, role accounts, and accept-all domains are technically "valid" but can damage your sender reputation. The safe_to_send field goes further. It filters out these risky categories and tells you which emails are truly safe for your campaigns. We strongly recommend using safe_to_send as your primary decision field.

How fast is the API response?

Most single email verification requests complete in under 1.2 seconds. This makes the API suitable for real-time form validation where users can see results as they interact with your signup flow. Response times may vary slightly for domains with slow-responding mail servers, but these edge cases are handled gracefully with timeout responses.

Do I get charged for unknown results?

No. QuickEmailVerification does not charge credits for results we cannot determine. If we return an "unknown" result due to timeouts, server unavailability, or other issues, no credits are deducted from your account. You only pay for definitive results. This can save significant credits compared to tools that charge for every request regardless of result quality.

Is there a sandbox or test mode?

Yes. The sandbox endpoint at /v1/verify/sandbox lets you test your integration with simulated, pre-defined responses. No credits are deducted for sandbox requests. You can simulate valid, invalid, disposable, role-based, catch-all, and other result types by using specific email formats like safe-to-send@example.com or disposable@example.com. This is useful for testing your application's handling of different verification outcomes before going to production.

What does the did_you_mean field do?

The did_you_mean field catches common typos in email domains. If a user enters "john@gmial.com," the API will return a suggestion of "john@gmail.com" in this field. You can use this in your signup forms to prompt users to correct their email instead of outright rejecting it, turning a lost signup into a recovered one. Every incorrectly typed email is a missed opportunity; this field helps you recover them.

How does pricing work for API usage?

You get 100 free credits every day, with no credit card required.

If you need more than 100 verifications per day, you can choose a premium plan:

- Pay-as-you-go (Persistent credits): Buy credits as needed. These credits never expire and can be used anytime.

- Monthly subscription (Per day credits): Get a fixed number of credits every day. These credits reset daily and do not roll over.

If both plans are active, Per day credits are used first, and persistent credits automatically act as a backup for any additional usage.

Auto-recharge is available for uninterrupted service. For high-volume requirements, contact us for volume pricing.

For details, please check our pricing page.

Can I restrict API access by IP address?

Yes. When creating your API key, you can specify allowed IP addresses or CIDR ranges. Requests from unauthorized IPs will be rejected. This adds an extra layer of security to prevent unauthorized use of your API key. You can manage IP restrictions from the API Settings section in your dashboard.

Get Started in 5 Minutes

From zero to verifying emails in production. Four steps, no calls, no demos.

1

Create API Key

Sign up free. Go to API Settings. Click "Add API Key." Takes 30 seconds.

2

Test with Sandbox

Use the /v1/verify/sandbox endpoint. No credits deducted. Test every result type.

3

Copy the Code

Pick your language. Install the SDK or use the cURL example above. Replace YOUR_API_KEY with your key.

4

Go to Production

Switch from /sandbox to /verify. Your first 100 credits/day are free. You're live.

Simple Pricing. No Surprises.

Pay-as-you-go credits that never expire. No subscriptions, no monthly commitments.

Free Tier

100

credits / day

No credit card required. Resets daily. Enough to test with real data and verify signups for small projects.

Pay As You Go

$4

for 500 credits

Credits never expire. Buy when you need them, use them at your own pace. No subscription required.

High Volume

Custom

pricing at scale

Auto-recharge available. Volume discounts for 5M+ verifications. Contact us for a quote.

Credits never expire
No charge for unknown results
No contracts or commitments
Auto-recharge available

300,000+ Businesses trust QuickEmailVerification

Join the thousands of satisfied customers who rely on us as the top platform for email validations