# Email Validator API Documentation

> Complete Email Validator API documentation with examples, parameters, authentication, and code samples. Email Validator is a simple tool for validating if an email address is valid or not. It checks the email address format and the domain records to see if the email address is valid. Fast, reliable, and easy to integrate.

# ![Email Validator](https://apiverve.web.app/publicapis/logos/emailvalidator.svg)Email Validator

OnlineCredit Usage:1 per callLatency:468ms avg

Email Validator is a simple tool for validating if an email address is valid or not. It checks the email address format and the domain records to see if the email address is valid.

This API provides reliable and fast access to email validator data through a simple REST interface. Built for developers who need consistent, high-quality results with minimal setup time.

To use this API, you need an API key. You can get one by [creating a free account](https://apiverve.com/signup) and visiting your [dashboard](https://apiverve.com/dashboard).

[View API in Directory](https://apiverve.com/marketplace/emailvalidator)

## GET Endpoint

URL

```http
https://api.apiverve.com/v1/emailvalidator
```

## Code Examples

Here are examples of how to call this API in different programming languages:

cURLJavaScriptPythonNode.jsPHPGoRubyC#

cURL Request

```bash
curl -X GET \
  "https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com" \
  -H "X-API-Key: your_api_key_here"
```

JavaScript (Fetch API)

```javascript
const response = await fetch('https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com', {
  method: 'GET',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);
```

Python (Requests)

```python
import requests

headers = {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
}

response = requests.get('https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com', headers=headers)

data = response.json()
print(data)
```

Node.js (Native HTTPS)

```javascript
const https = require('https');
const url = require('url');

const options = {
  method: 'GET',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json'
  }
};

const req = https.request('https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com', options, (res) => {
  let data = '';
  res.on('data', (chunk) => data += chunk);
  res.on('end', () => console.log(JSON.parse(data)));
});

req.end();
```

PHP (cURL)

```php
<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: your_api_key_here',
    'Content-Type: application/json'
]);

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

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

?>
```

Go (net/http)

```go
package main

import (
    "fmt"
    "io"
    "net/http"

)

func main() {
    req, _ := http.NewRequest("GET", "https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com", nil)

    req.Header.Set("X-API-Key", "your_api_key_here")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

Ruby (Net::HTTP)

```ruby
require 'net/http'
require 'json'

uri = URI('https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['X-API-Key'] = 'your_api_key_here'
request['Content-Type'] = 'application/json'

response = http.request(request)
puts JSON.pretty_generate(JSON.parse(response.body))
```

C# (HttpClient)

```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-Key", "your_api_key_here");

        var response = await client.GetAsync("https://api.apiverve.com/v1/emailvalidator?email=support@myspace.com");
        response.EnsureSuccessStatusCode();

        var responseBody = await response.Content.ReadAsStringAsync();
        Console.WriteLine(responseBody);
    }
}
```

## Authentication

This API requires authentication via API key. Include your API key in the request header:

Required Header

```
X-API-Key: your_api_key_here
```

## Interactive API Playground

Test this API directly in your browser with live requests and responses.

[

**Open in API Playground**Test with your API key in the dashboard

](https://dashboard.apiverve.com/playground?id=emailvalidator)

## Parameters

The following parameters are available for this API endpoint:

Parameter

Type

Required

Description

Default

Example

email

string

Yes

The email address to validate (e.g., support@myspace.com)

\-

support@myspace.com

## Response

The API returns responses in JSON, XML, YAML, Markdown, and CSV formats:

### Example Responses

JSONXMLYAMLMarkdownCSV

JSON Response

200 OK

```json
{
  "status": "ok",
  "error": null,
  "data": {
    "creationDate": null,
    "domain": "myspace.com",
    "email": "support@myspace.com",
    "username": "support",
    "canConnect": true,
    "hasTypo": false,
    "isValid": true,
    "isMxValid": true,
    "isSmtpValid": true,
    "isRegexValid": true,
    "smtp": {
      "valid": true,
      "reason": "Connected"
    },
    "isCompanyEmail": true,
    "isFreeEmail": false,
    "checksum": 797
  }
}
```

XML Response

200 OK

```xml
<Root>
  <status>ok</status>
  <error />
  <data>
    <creationDate />
    <domain>myspace.com</domain>
    <email>support@myspace.com</email>
    <username>support</username>
    <canConnect>true</canConnect>
    <hasTypo>false</hasTypo>
    <isValid>true</isValid>
    <isMxValid>true</isMxValid>
    <isSmtpValid>true</isSmtpValid>
    <isRegexValid>true</isRegexValid>
    <smtp>
      <valid>true</valid>
      <reason>Connected</reason>
    </smtp>
    <isCompanyEmail>true</isCompanyEmail>
    <isFreeEmail>false</isFreeEmail>
    <checksum>797</checksum>
  </data>
</Root>
```

YAML Response

200 OK

```yaml
status: ok
error: 
data:
  creationDate: 
  domain: myspace.com
  email: support@myspace.com
  username: support
  canConnect: true
  hasTypo: false
  isValid: true
  isMxValid: true
  isSmtpValid: true
  isRegexValid: true
  smtp:
    valid: true
    reason: Connected
  isCompanyEmail: true
  isFreeEmail: false
  checksum: 797
```

Markdown Response

200 OK

```markdown
| Field | Value |
| --- | --- |
| status | ok |
| error |  |
| creationDate |  |
| domain | myspace.com |
| email | support@myspace.com |
| username | support |
| canConnect | True |
| hasTypo | False |
| isValid | True |
| isMxValid | True |
| isSmtpValid | True |
| isRegexValid | True |
| smtp.valid | True |
| smtp.reason | Connected |
| isCompanyEmail | True |
| isFreeEmail | False |
| checksum | 797 |
```

CSV Response

200 OK

status

error

creationDate

domain

email

username

canConnect

hasTypo

isValid

isMxValid

isSmtpValid

isRegexValid

smtp.valid

smtp.reason

isCompanyEmail

isFreeEmail

checksum

ok

myspace.com

support@myspace.com

support

True

False

True

True

True

True

True

Connected

True

False

797

[Live Test API in Playground](https://dashboard.apiverve.com/playground?api=emailvalidator)

### Response Structure

All API responses follow a consistent structure with the following fields:

Field

Type

Description

Example

status

string

Indicates whether the request was successful ("ok") or failed ("error")

ok

error

string | null

Contains error message if status is "error", otherwise null

null

data

object | null

Contains the API response data if successful, otherwise null

{...}

### Response Data Fields

When the request is successful, the `data` object contains the following fields:

Field

Type

Sample Value

creationDate

object

null

domain

string

"myspace.com"

email

string

"support@myspace.com"

username

string

"support"

canConnect

boolean

true

hasTypo

boolean

false

isValid

boolean

true

isMxValid

boolean

true

isSmtpValid

boolean

true

isRegexValid

boolean

true

smtp

object

{...}

└ valid

boolean

true

└ reason

string

"Connected"

isCompanyEmail

boolean

true

isFreeEmail

boolean

false

checksum

number

797

## Headers

Required and optional headers for API requests:

Header Name

Required

Example Value

Description

X-API-Key

Yes

your\_api\_key\_here

Your APIVerve API key. Found in your dashboard under API Keys.

Accept

No

application/json

Specify response format: application/json (default), application/xml, or application/yaml

User-Agent

No

MyApp/1.0

Identifies your application for analytics and debugging purposes

X-Request-ID

No

req\_123456789

Custom request identifier for tracking and debugging requests

Cache-Control

No

no-cache

Control caching behavior for the request and response

## GraphQL AccessALPHA

Most APIVerve APIs support GraphQL queries, allowing you to combine multiple API calls into a single request and retrieve only the data you need. This powerful feature enables you to orchestrate complex data fetching with precise field selection.

Not all APIs support GraphQL. Check the API schema or test in the GraphQL Explorer to confirm availability for this specific endpoint.

**Credit Cost:** Each API called in your GraphQL query consumes its standard credit cost.

GraphQL Endpoint

```http
POST https://api.apiverve.com/v1/graphql
```

GraphQL Query Example

```graphql
query {
  emailvalidator(
    input: {
      email: "support@myspace.com"
    }
  ) {
    creationDate
    domain
    email
    username
    canConnect
    hasTypo
    isValid
    isMxValid
    isSmtpValid
    isRegexValid
    smtp {
      valid
      reason
    }
    isCompanyEmail
    isFreeEmail
    checksum
  }
}
```

**Note:** Authentication is handled via the `x-api-key` header in your GraphQL request, not as a query parameter.

[Try in GraphQL Explorer](https://dashboard.apiverve.com/vervekit/graphql)[GraphQL Documentation](/graphql/usage)

## CORS Support

All APIVerve APIs support Cross-Origin Resource Sharing (CORS) with wildcard configuration, allowing you to call the API directly from browser-based applications without proxy servers.

CORS Header

Value

Description

Access-Control-Allow-Origin

\*

Accepts requests from any origin

Access-Control-Allow-Methods

\*

Accepts any HTTP method

Access-Control-Allow-Headers

\*

Accepts any request headers

**Browser Usage:** You can make direct API calls from JavaScript running in the browser without encountering CORS errors. No additional configuration needed.

## Rate Limiting

APIVerve implements rate limiting to ensure fair usage and maintain service quality across all users. Rate limits vary by subscription plan and are applied per API key.

Plan

Rate Limit

Description

Free

5 requests/min

Hard rate limit enforced - exceeding will return 429 errors

Starter

No Limit

Production ready - no rate limiting or throttling

Pro

No Limit

Production ready - no rate limiting or throttling

Mega

No Limit

Production ready - no rate limiting or throttling

### Rate Limit Headers

When rate limits apply, each API response includes headers to help you track your usage:

Header

Description

X-RateLimit-Limit

Maximum number of requests allowed per time window

X-RateLimit-Remaining

Number of requests remaining in the current window

X-RateLimit-Reset

Unix timestamp when the rate limit window resets

### Handling Rate Limits

**Free Plan:** When you exceed your rate limit, the API returns a `429 Too Many Requests` status code. Your application should implement appropriate backoff logic to handle this gracefully.

**Paid Plans:** No rate limiting or throttling applied. All paid plans (Starter, Pro, Mega) are production-ready.

**Best Practices:**

-   Monitor the rate limit headers to track your usage (Free plan only)
-   Implement caching where appropriate to reduce API calls
-   Upgrade to Pro or Mega for guaranteed no-throttle performance

**Note:** Rate limits are separate from credit consumption. You may have credits remaining but still hit rate limits on Free tier.

## Client Libraries

To get started with minimal code, most of our APIs are available through client libraries and clients:

[![NPM](/images/npm.png)](https://www.npmjs.com/~apivervehq)[![PyPI](/images/pypi.png)](https://pypi.org/user/apiverve/)[![NuGet](/images/nuget.png)](http://nuget.org/profiles/APIVerve)[![Swagger](/images/swagger.png)](https://apiverve.web.app/publicapis/api-schema/emailvalidator.json)

## Error Codes

The API uses standard HTTP status codes to indicate success or failure:

Code

Message

Description

Solution

200

OK

Request successful, data returned

No action needed - request was successful

400

Bad Request

Invalid request parameters or malformed request

Check required parameters and ensure values match expected formats

401

Unauthorized

Missing or invalid API key

Include x-api-key header with valid API key from dashboard

403

Forbidden

API key lacks permission or insufficient credits

Check credit balance in dashboard or upgrade plan

429

Too Many Requests

Rate limit exceeded (Free: 5 req/min)

Implement request throttling or upgrade to paid plan

500

Internal Server Error

Server error occurred

Retry request after a few seconds, contact support if persists

503

Service Unavailable

API temporarily unavailable

Wait and retry, check status page for maintenance updates

**Need help?** [Contact support](https://apiverve.com/contact) with your `X-Request-ID` for assistance.

## Frequently Asked Questions

How do I get an API key?

Sign up for a free account at [dashboard.apiverve.com](https://dashboard.apiverve.com). Your API key will be automatically generated and available in your dashboard. The free plan includes 1,000 credits plus a 500 credit bonus.

What are credits and how do they work?

Credits are your API usage currency. Each successful API call consumes credits based on the API's complexity. Most APIs cost 1 credit per call, while more complex APIs may cost 2-5 credits. Failed requests and errors don't consume credits. Check the API details above to see the credit cost for this specific API.

Can I use this API in production?

The free plan is for testing and development only. For production use, upgrade to a paid plan (Starter, Pro, or Mega) which includes commercial use rights, no attribution requirements, and guaranteed uptime SLAs. All paid plans are production-ready.

Can I use this API from a browser?

Yes! All APIVerve APIs support CORS with wildcard configuration, so you can call them directly from browser-based JavaScript without needing a proxy server. See the [CORS section](#cors) above for details.

What happens if I exceed my credit limit?

When you reach your monthly credit limit, API requests will return an error until you upgrade your plan or wait for the next billing cycle. You'll receive notifications at 80% and 95% usage to give you time to upgrade if needed.

## People who used this also used...

Based on your interest in Email Validator, you might also like these APIs:

[

![Phone Number Validator](https://apiverve.web.app/publicapis/logos/phonenumbervalidator.svg)

### Phone Number Validator

Phone Number Validator is a simple tool for validating if a phone number is valid or not. It checks the phone number format and the country code to see if the phone number is valid.

1 credit per call

](/ref/phonenumbervalidator)[

![Card Validator](https://apiverve.web.app/publicapis/logos/cardvalidator.svg)

### Card Validator

Card Validator is a simple tool for validating if a card number is valid or not. It checks the card number format and the Luhn algorithm to see if the card number is valid.

1 credit per call

](/ref/cardvalidator)[

![Spam Detector](https://apiverve.web.app/publicapis/logos/spamdetector.svg)

### Spam Detector

Spam Detector is a simple tool for detecting spam in a text. It utilize an email address or IP address to validate the given text against the spam database.

1 credit per call

](/ref/spamdetector)

## What's Next?

Continue your journey with these recommended resources

[

### Browse All APIs

Explore our complete catalog of APIs

](/api-endpoints)[

### Authentication Guide

Learn about API keys and security

](/authentication)[

### Rate Limits

Understand usage limits and best practices

](/rate-limits)

Help us improve our documentation

YesNo

Copy for LLM[View as Markdown](/ref/emailvalidator/ai.md "View this page as plain markdown")[Star](https://github.com/apiverve/emailvalidator-api "Star emailvalidator API on GitHub")

---

*Source: [docs.apiverve.com/ref/emailvalidator](https://docs.apiverve.com/ref/emailvalidator)*