Name: Email Validation API: Verify Email Address & MX Records
Brand: codezic
SKU: api-codezic-emailvalidation
Availability: InStock
Author: API Market

sujith raman


# 📧 Email Verification API – Validate Emails with Domain & MX Check

## Overview

The Email Verification API allows developers to programmatically validate email addresses using a REST API. It performs several checks, including email format validation, domain extraction, and MX record verification, to ensure the email address is both syntactically correct and capable of receiving emails. This API is crucial for improving data quality, reducing bounce rates, and preventing fraud in web applications, mobile applications, and other online services.

## Features

*   **Email Format Validation:** Checks if the email address adheres to standard formatting rules.
*   **Domain Extraction:** Extracts the domain name from the email address.
*   **MX Record Verification:** Verifies the existence and validity of MX records for the extracted domain, indicating whether the domain is configured to receive emails.
*   **Fast Response Time:** Provides rapid validation results, ensuring minimal impact on application performance.
*   **JSON-Based Output:** Returns validation results in a structured JSON format for easy parsing and integration.
*   **Secure API Key Authentication:** Protects the API with secure API key-based authentication.
*   **Simple REST API:** Offers an intuitive REST interface for straightforward integration into existing systems.

## Use Cases

*   **E-commerce User Registration:** Validate user-provided email addresses during the signup process to prevent invalid or disposable emails, reducing fraud and improving data quality.
*   **Email Marketing Campaign Optimization:** Clean email lists by verifying email addresses before sending marketing campaigns to minimize bounce rates and improve sender reputation.
*   **Customer Relationship Management (CRM) Data Cleaning:** Regularly validate email addresses stored in your CRM to ensure data accuracy and improve communication effectiveness with customers.
*   **Account Recovery Process:** Verify that an email address provided for account recovery is valid and capable of receiving emails, enhancing the security of the recovery process.
*   **Form Submission Validation:** Validate emails addresses entered through web forms in real time, providing immediate feedback to users and preventing invalid submissions.


## API Documentation

### Base URL

All API requests should be made to: `https://prod.api.market/api/v1/magicapi/emailvalidation`

### Authentication

Authentication is handled via API key. Include your API key in the `x-api-market-key` request header:

```
x-api-market-key: YOUR_API_MARKET_KEY
```



### Endpoints

#### Verify Email Address

```http
GET /api/verify
```

This endpoint validates an email address and checks its domain and MX records.

##### Request

**Headers:**

```
x-api-market-key: YOUR_API_MARKET_KEY
```

**Query Parameters:**

| Parameter | Type   | Required | Description               |
| --------- | ------ | -------- | ------------------------- |
| email     | string | Yes      | Email address to validate |

##### Example Request

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/emailvalidation/api/verify?email=test@gmail.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

##### Response

**✅ Success Response (Status Code: 200 OK):**

```json
{
  "success": true,
  "data": {
    "email": "test@gmail.com",
    "valid": true,
    "domain": "gmail.com",
    "mx": true
  }
}
```

**❌ Error Response (Status Code: 400 Bad Request):**

```json
{
  "error": "Invalid or missing 'email' parameter"
}
```

#### Get Prediction Status

```http
GET /api/v1/magicapi/emailvalidation/predictions/{id}
```

This endpoint retrieves the status of a specific prediction.

##### Request

**Headers:**

```
x-api-market-key: YOUR_API_MARKET_KEY
```

**Path Parameters:**

| Parameter | Type   | Required | Description                  |
| --------- | ------ | -------- | ---------------------------- |
| id        | string | Yes      | The ID of the prediction.    |

##### Example Request

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/emailvalidation/predictions/12345" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

##### Response

**✅ Success Response (Status Code: 200 OK - Processing):**

```json
{
  "id": "12345",
  "status": "processing",
  "input": {
    "email": "test@gmail.com"
  }
}
```

**✅ Success Response (Status Code: 200 OK - Succeeded):**

```json
{
  "id": "12345",
  "status": "succeeded",
  "input": {
    "email": "test@gmail.com"
  },
   "output": {
    "success": true,
    "data": {
      "email": "test@gmail.com",
      "valid": true,
      "domain": "gmail.com",
      "mx": true
    }
  }
}
```

**❌ Error Response (Status Code: 404 Not Found):**

```json
{
  "error": "Prediction not found"
}
```

## Status Codes

*   **200 OK:** Request successful.
*   **201 Created:** Resource successfully created (not used in this API).
*   **400 Bad Request:** Invalid input parameters or malformed request.
    *   *Explanation:* This indicates that the provided input data (e.g., email address) is invalid or missing.
    *   *How to handle:* Check the request parameters and ensure they meet the required format and constraints.
*   **401 Unauthorized:** Missing or invalid API key.
    *   *Explanation:* This means that the API key is either missing from the request headers or is invalid.
    *   *How to handle:* Verify that the `x-api-market-key` header is present and contains a valid API key.
*   **403 Forbidden:** Valid API key but insufficient permissions (not used in this API).
*   **404 Not Found:** Resource not found.
    *   *Explanation:*  This indicates that the requested resource (e.g., a prediction with a specific ID) does not exist.
    *   *How to handle:* Double-check the resource identifier and ensure it is correct.
*   **429 Too Many Requests:** Rate limit exceeded.
    *   *Explanation:* This occurs when the API usage exceeds the allowed rate limit.
    *   *How to handle:* Implement a retry mechanism with exponential backoff to avoid overwhelming the API.
*   **500 Internal Server Error:** Server-side error.
    *   *Explanation:* This indicates an unexpected error on the server-side.
    *   *How to handle:*  Retry the request after a short delay. If the error persists, contact support.
*   **503 Service Unavailable:** Service temporarily unavailable.
    *   *Explanation:* The service is temporarily unavailable due to maintenance or high load.
    *   *How to handle:* Retry the request after a short delay.

## Rate Limits

Rate limit information can be found on your API.market dashboard. If you exceed the limit, implement a retry mechanism with exponential backoff.

## Error Handling

Proper error handling is crucial for building robust applications. The API returns detailed error responses in JSON format to help you diagnose and resolve issues.

Here are some error handling best practices:

*   **Interpret Error Responses:** Always parse the JSON response and check for an "error" field.
*   **Common Errors and Resolutions:**
    *   `Invalid or missing 'email' parameter` (Status 400):  Ensure the `email` query parameter is present and contains a valid email address.
    *   `Missing or invalid API key` (Status 401): Verify that the `x-api-market-key` header is included and contains a valid API key.
    *   `Prediction not found` (Status 404): Ensure the prediction ID is correct.
*   **Retry Strategies:** For transient errors like 500 Internal Server Error or 503 Service Unavailable, implement a retry mechanism with exponential backoff. Start with a short delay (e.g., 1 second) and double the delay with each subsequent attempt, up to a maximum delay (e.g., 30 seconds).

Example Error Response:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'email' is required",
    "status": 400
  }
}
```

## Implementation Guide

This section provides detailed guidance on how to implement and use the Email Validation API effectively.

### Example Code

The following examples demonstrate how to authenticate with the API, make requests, handle responses, and implement retries for long-running operations.

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/emailvalidation";

async function validateEmail(email) {
  try {
    // Step 1: Create the prediction (validate email)
    const response = await fetch(`${baseUrl}/api/verify?email=${email}`, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey
      },
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const data = await response.json();
	return data;

  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}
```

```python
# Python example with polling is unneccesary since verify is a get request
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/emailvalidation"

def validate_email(email):
    # Step 1: Create the prediction
    headers = {
        "x-api-market-key": API_KEY
    }
    
    response = requests.get(
        f"{BASE_URL}/api/verify?email={email}",
        headers=headers
    )
    
    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    return prediction
```

```bash
# cURL example (can be simpler, just show the basic commands)
# Step 1: Create a prediction
curl -X GET "https://prod.api.market/api/v1/magicapi/emailvalidation/api/verify?email=test@gmail.com" -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Response will contain a prediction ID like:
# {"success": true, "data": {"email": "test@gmail.com", "valid": true, "domain": "gmail.com", "mx": true}}
```

### Performance Optimization

*   **Cache Frequent Validation Results:** Cache validation results for frequently validated email addresses to reduce API calls and improve performance.
*   **Handle 400 and 401 Errors Properly:** Implement proper error handling to avoid unnecessary retries and ensure a smooth user experience.
*   **Avoid Exposing API Keys:** Never expose API keys in client-side code. Use a backend proxy to securely handle API requests.
*   **Monitor API Usage:** Monitor API usage and limits to prevent unexpected costs and ensure optimal performance.

## FAQ

**Q: What checks does the Email Validation API perform?**

A: The API performs email format validation, domain extraction, and MX record verification.

**Q: How do I authenticate with the API?**

A: Use your API.market API key in the `x-api-market-key` header.

**Q: What happens if I exceed the rate limit?**

A: Implement a retry mechanism with exponential backoff.

**Q: What if I receive an Internal Server Error?**

A: Retry the request after a short delay. If the error persists, contact support.

**Q: How long does the validation process take?**

A: The validation process is usually instantaneous.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@api.market.
```

Validate email addresses with our Email Validation API. Check domain & MX records for deliverability. Fast, reliable email verification!