EmailVerify LogoEmailVerify

Quickstart

Get started with email checker API in 5 minutes. Free API key, code examples, and email verification integration guide.

Get up and running with the EmailVerify API in just 5 minutes. This guide walks you through verifying your first email address.

Prerequisites

Before you begin, you'll need:

  • A EmailVerify account (Sign up free)
  • Basic knowledge of HTTP requests or familiarity with one of our supported languages

Step 1: Create an Account

  1. Visit EmailVerify and click Get Started
  2. Sign up with your email or Google/GitHub account
  3. Verify your email address

Step 2: Get Your API Key

  1. Log in to your EmailVerify dashboard
  2. Navigate to the API Keys section
  3. Click Create New Key
  4. Give your key a descriptive name (e.g., "Development", "Production")
  5. Copy your API key and store it securely

Never expose your API key in client-side code or public repositories. Use environment variables to store your key securely.

Step 3: Verify Your First Email

Choose your preferred method to make your first verification request:

curl -X POST https://api.emailverify.ai/v1/verify \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "test@example.com"}'
const response = await fetch('https://api.emailverify.ai/v1/verify', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: 'test@example.com',
  }),
});

const result = await response.json();
console.log(result);
import os
import requests

response = requests.post(
    'https://api.emailverify.ai/v1/verify',
    headers={
        'Authorization': f'Bearer {os.environ["EMAILVERIFY_API_KEY"]}',
        'Content-Type': 'application/json',
    },
    json={'email': 'test@example.com'}
)

result = response.json()
print(result)
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    data := map[string]string{"email": "test@example.com"}
    body, _ := json.Marshal(data)

    req, _ := http.NewRequest("POST",
        "https://api.emailverify.ai/v1/verify",
        bytes.NewBuffer(body))

    req.Header.Set("Authorization", "Bearer "+os.Getenv("EMAILVERIFY_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}
<?php
$apiKey = getenv('EMAILVERIFY_API_KEY');

$ch = curl_init('https://api.emailverify.ai/v1/verify');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['email' => 'test@example.com']),
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

Step 4: Understand the Response

A successful verification returns a response like this:

{
  "email": "test@example.com",
  "status": "valid",
  "result": {
    "deliverable": true,
    "valid_format": true,
    "valid_domain": true,
    "valid_mx": true,
    "disposable": false,
    "role": false,
    "catchall": false,
    "free": false,
    "smtp_valid": true
  },
  "score": 0.95,
  "credits_used": 1
}

Key Response Fields

FieldTypeDescription
statusstringOverall status: valid, invalid, unknown, or accept_all
deliverablebooleanWhether the email can receive messages
disposablebooleanWhether it's a temporary/disposable email
rolebooleanWhether it's a role-based address (info@, support@)
catchallbooleanWhether the domain accepts all emails
scorenumberConfidence score from 0 to 1 (higher is better)

Status Values Explained

StatusMeaningRecommended Action
validEmail exists and can receive messagesSafe to send
invalidEmail doesn't exist or can't receive messagesRemove from list
unknownCouldn't determine statusRetry later or use caution
accept_allDomain accepts all emails (catch-all)Monitor for bounces

For easier integration, install one of our official SDKs:

npm install @emailverify/node
import { EmailVerify } from '@emailverify/node';

const client = new EmailVerify({
  apiKey: process.env.EMAILVERIFY_API_KEY,
});

const result = await client.verify('test@example.com');
console.log(result.status); // 'valid'
pip install emailverify
from emailverify import Client
import os

client = Client(api_key=os.environ['EMAILVERIFY_API_KEY'])
result = client.verify('test@example.com')
print(result.status)  # 'valid'
go get github.com/emailverify/go-sdk
import emailverify "github.com/emailverify/go-sdk"

client := emailverify.NewClient(os.Getenv("EMAILVERIFY_API_KEY"))
result, err := client.Verify(ctx, "test@example.com")
fmt.Println(result.Status) // "valid"
composer require emailverify/php-sdk
use EmailVerify\Client;

$client = new Client(getenv('EMAILVERIFY_API_KEY'));
$result = $client->verify('test@example.com');
echo $result->status; // 'valid'
<dependency>
    <groupId>com.emailverify</groupId>
    <artifactId>emailverify-java</artifactId>
    <version>1.0.0</version>
</dependency>
import com.emailverify.Client;

Client client = new Client(System.getenv("EMAILVERIFY_API_KEY"));
VerificationResult result = client.verify("test@example.com");
System.out.println(result.getStatus()); // "valid"

What's Next?

Now that you've verified your first email, explore more features:

Common Use Cases

Form Validation

Verify emails in real-time during user registration:

const onEmailBlur = async (email) => {
  const result = await client.verify(email);

  if (result.status === 'invalid') {
    showError('Please enter a valid email');
  } else if (result.result.disposable) {
    showError('Disposable emails are not allowed');
  }
};

List Cleaning

Clean your email list before sending campaigns:

for email in email_list:
    result = client.verify(email)
    if result.status == 'valid':
        clean_list.append(email)
    else:
        remove_list.append(email)

Lead Qualification

Score leads based on email quality:

const qualifyLead = (verificationResult) => {
  let score = verificationResult.score * 50; // Base score

  if (!verificationResult.result.free) score += 20;      // Business email
  if (!verificationResult.result.role) score += 15;      // Personal address
  if (!verificationResult.result.disposable) score += 15; // Permanent email

  return score;
};

Need Help?

On this page