Avail 10% off use DISCOUNT10, No credit card required! Signup NOW 🚀

Introduction Last updated: 2022-04-18

Elite EmailVerifier API

With the Elite Email Verifier API, you get the unique ability to verify thousands of email addresses in real-time. It has been built for optimization and includes a single endpoint for fast lookups. Its simplicity makes it easy to integrate into any application, without having to worry about thousands of lines of code or complex configurations.

API Concepts

In order to access our API, Emailverifier uses API keys. For API requests to the server, Emailverifier expects the API key to be included as an Authorization parameter.

Tip

Using the api variable in request headers, API tokens must be provided for all requests. Our API requires authentication for all requests.

Example:
Curl curl -H "Authorization: Token {your_token_here}" -X POST 'https://emailverifier.co/v1/' -d '{"email":"example@example.com"}'

To create an API key please create an account by signing up & navigate to the API section.

Responses

A JSON format is used to receive all data. A success parameter is included in each response sent from the API. This parameter indicates whether or not the request was successful, with 1 being successful and 0 being unsuccessful. Optionally, an error (string) parameter can be provided when success is 0. As long as success is 1, the response will always be encapsulated in an EmailVeriifier parameter.

Here are JSON responses for Successful and Error Response

Success response JSON schema:

JSON
							  
	  HTTP/1.1 200 OK
	{
	   "email_verifier":{
		  "email":"john.doe@dmail.com",
		  "code":"5",
		  "role":"false",
		  "free_email":"true",
		  "result":"Safe to Send",
		  "reason":"Deliverable",
		  "send_transactional":"1",
		  "did_you_mean":""
	   },
	   "success":"1",
	   "balance":"1725935"
	}
	
	
						  
Error response JSON schema:
							  
   HTTP/1.1 401 Unauthorized
	
	{
	"email_verifier":{
	  "error":"Wrong API",
		"code":"0"
   },
   "success":"0"
	} 
	
						  

Security

Elite EmailVerifier's APIs are all rate-limited to ensure the stability and fairness of our platform. Developers are asked to limit calls, cache results, and retry requests responsibly according to industry standards. There can be a maximum of 10 concurrent calls (parallel connections). With a higher validation speed, you'll receive the following error:

							  
  HTTP/ 429 Too Many Requests
  
  {
	 "email_verifier":{
		"error":"Maximum concurrent calls reached",
		"code":"0"
	 },
	 "success":"0"
  }
   
 

Public API Key

Codes in JavaScript can be used to access the public API key which starts with public_. Your domain URL must be added to the approved CORS domain list of the API key in order to use it.

When you create your public API key, we ask you to create a list of trusted domains in order to prevent abuse. Requests made with a public API key will only work if they come from a trusted domain. Requests will also be limited to 20 per day per user.

You will get the following error if you attempt to validate more than 20 emails with the same internet IP address:

								  
	  HTTP/ 429 Too Many Requests
	   {
	  "email_verifier":{
			"error":"Authentication Failed - The maximum number of calls per day reached."
		  },
	  "success":"0"
		  }
	  
	  

Bulk validation API

The bulk validation API can validate a single list at a time. You can queue your bulk API job and it will run automatically once your first job is completed if you already uploaded and started a list using the list upload feature on Emailverifier.

STATUS CODES

Elite EmailVerifier API uses following status codes:

Code Response Meaning
249 Try Again Your request is taking longer than normal. You may have to send your request again.
400 Bad Request Your request is structured incorrectly.
401 Unauthorized You did not send an API key.
402 Payment Required You don't have enough credits to complete this request.
403 Forbidden Your API key is invalid.
404 Not Found The specified resource does not exist.
429 Too Many Requests You're requesting an endpoint too often.
500 Internal Server Error A server error occurred. Please try again later, or contact support if you're having trouble.
503 Service Unavailable We're temporarily offline for maintenance. Please try again later.

Email Validation

Single Validation

Verify one email at a time. You may retry a verification request up to five times if it takes longer than the timeout. Any further requests will count against your usage after 5 minutes have passed. When the verification results are available, you will be notified.

A random sample response will be returned when a test key is used.

HTTP GET Request:
https://api.emailverifier.co/v1/verify

Parameters for Single validation:
Parameter Required Description
email true The email you want verified.
smtp false "true" or "false". The SMTP step takes up a majority of the API's response time. If you would like to speed up your response times, you can disable this step. Default: true
accept_all false "true" or "false". Whether or not an accept-all check is performed. Heavily impacts API's response time. Default: false
timeout false Optional timeout to wait for response (in seconds). Min: 5, Max: 30. Default: 5
api_key true Your API key.
Response
Attribute Type Description
accept_all Boolean Whether the mail server used to verify indicates that all addresses are deliverable regardless of whether or not the email is valid.
did_you_mean String A suggested correction for a common misspelling.
disposable Boolean Whether this email is hosted on a disposable or temporary email service.
domain String The domain of the email. (e.g. The domain for jane.doe@dmail.com would be dmail.com)
duration Float The length of time (in seconds) spent verifying this email.
email String The email that was verified.
first_name String The possible first name of the user.
free Boolean Whether the email is hosted by a free email provider.
full_name String The possible full name of the user.
gender String The possible gender of the user.
last_name String The possible last name of the user.
mx_record String The address of the mail server used to verify the email.
reason String The reason for the associated state.
role Boolean Whether the email is considered a role address. (e.g. support, info, etc.)
score Integer The score of the verified email.
smtp_provider String The SMTP provider of the verified email's domain.
state String The state of the verified email. (e.g. deliverable, undeliverable, risky, unknown)
tag String The tag part of the verified email. (e.g. The tag for john.smith+demo@dmail.com would be demo)
user String The user part of the verified email. (e.g. The user for john.smith@dmail.com would be john.smith)

Curl
Request
			
	curl --request GET \
	     --url https://api.emailverifier.co/v1/ \
		 --header 'Accept: application/json' 	
	
								

Response
								  
	   HTTP/1.1 200 OK
  {
	 "email_verifier":{
		"email":"john@dmail.com",
		"code":"5",
		"role":"false",
		"free_email":"true",
		"result":"Safe to Send",
		"reason":"Deliverable",
		"send_transactional":"1",
		"did_you_mean":""
	 },
	 "success":"1",
	 "balance":"1926545"
  }
  
							  

Python
Installation: python -m pip install requests
Request
								  
  
	  import requests
  
	  url = "https://api.emailverifier.co/v1/"
	  
	  headers = {"Accept": "application/json"}
	  
	  response = requests.request("GET", url, headers=headers)
	  
	  print(response.text)
  
							  

Response
							  
	  HTTP/1.1 200 OK
	  {
	 "email_verifier":{
		"email":"john.doe@dmail.com",
		"code":"5",
		"role":"false",
		"free_email":"true",
		"result":"Safe to Send",
		"reason":"Deliverable",
		"send_transactional":"1",
		"did_you_mean":""
		},
	  "success":"1",
	  "balance":"1725935"
	  }
	  
	  

PHP
Installation: composer require guzzlehttp/guzzle
Request
	 
		
	request('GET', 'https://api.emailverifier.co/v1/', 
	['headers' => [
	'Accept' => 'application/json',
	 ],
	]);
	echo $response->getBody();
	  
  

Response
	 
	HTTP/1.1 200 OK
		{
  "email_verifier":{
     "email":"john.doe@dmail.com",
	  "code":"5",
	  "role":"false",
	  "free_email":"true",
	  "result":"Safe to Send",
	  "reason":"Deliverable",
	  "send_transactional":"1",
	  "did_you_mean":""
	},
 "success":"1",
     "balance":"1725935"
	}
		  
	

NodeJS
Installation: npm install node-fetch --save
Request
  
const fetch = require('node-fetch');

const url = 'https://api.emailverifier.co/v1/';
const options = {method: 'GET', headers: {Accept: 'application/json'}};

fetch(url, options)
  .then(res => res.json())
  .then(json => console.log(json))
  .catch(err => console.error('error:' + err));
		  
  

Response
									  
HTTP/1.1 200 OK
	{
	  "email_verifier":{
		  "email":"john.doe@dmail.com",
		  "code":"5",
		  "role":"false",
		  "free_email":"true",
		  "result":"Safe to Send",
		  "reason":"Deliverable",
		  "send_transactional":"1",
		  "did_you_mean":""
	 },
	   "success":"1",
	   "balance":"1725935"
	}
	 
		

Bulk Validation

Verify a batch of emails. Separate each email using a comma and send it as a parameter email. A batch can consist of up to 50,000 emails.

It is possible to encode data using application/x-www-form-urlencoded, multipart/form-data, or application/json. All parameters should be sent in the HTTP request body, not in the URL query string.

Upon batch completion, the results will be sent to that URL via HTTP POST. As with the batch status endpoint below (GET /v1/batch), the body will be JSON data. A successful batch creation response with an example batch id will be returned when a test key is used. Furthermore, the simulate parameter can be utilized to simulate certain API responses in conjunction with a test key.

HTTP Request:
POST- https://api.emailverifier.co/v1/batch
Parameters
Parameter Required Description
emails true A comma separated list of emails.
url false A URL that will receive the batch results via HTTP POST.
api_key true Your API key.
retries false Defaults to true. Retries increase accuracy by automatically retrying verification when our system receives certain responses from mail servers. To speed up verification, you can disable this by setting retries to false; however, doing so may increase the number of unknown responses.
simulate false Used to simulate certain responses from the API while using a test key. Valid options are generic_error, insufficient_credits_error, payment_error, and card_error.
Response
Attribute Type Description
message String A message about your batch.
id String The unique ID of the batch.
Status Codes

With the "id" parameter specified as the request parameter, the batch endpoint will return the current status of the batch verification job.

The billing related messages will be returned if an error occurs when a credit card transaction is needed to obtain enough credits to verify a batch. A 402 response code will be returned.

A random sample response will be returned for each email in the batch when a test key is used. A test key can also simulate certain API responses by utilizing the simulate parameter. The batch status endpoint will no longer return individual email verification results after 30 days. Instead, aggregate counts will be returned.

HTTP Status Codes

HTTP Request:
GET - https://api.emailverifier.co/v1/batch
Parameters:
Parameter Required Description
id true The id of the batch.
api_key true Your API key.
partial false Defaults to false. A boolean value indicating whether to include partial results when a batch is still verifying.
simulate false Used to simulate certain responses from the API while using a test key. Valid options are generic_error, importing, verifying, and paused.
Response:
Attribute Type Description
message String A message about your batch.
processed Integer The number of emails that have been verified in the batch.
total Integer The total number of emails in your batch.
emails Array An array containing responses for each email in the batch. (See single email verification for more information on the response object.)
id String The unique ID of the batch.
reason_counts Hash A hash with one key per possible reason attribute. The values are integers representing the number of emails with that reason.
total_counts Hash A hash with one key per possible state attribute. The values are integers representing the number of emails with that state. In addition to the state keys, total_counts also contains keys processed and total, with values indicating the number of emails in the batch.

Get Started in No Time

Start verifying your emails in no time with Elite Email Verifier. No Credit Card required :)