Name: HaltBounce – Real-Time Email Verification | Free · $39/mo | API.market
Brand: haltbounce
SKU: api-haltbounce-verify
Availability: InStock
Author: API Market

# 📧 Verify Emails: Boost Deliverability with HaltBounce Email Verification

## Overview

Stop bad emails before they damage your sender reputation. HaltBounce is a real-time email verification API that checks whether a mailbox actually exists, detects disposable addresses, identifies role accounts and potential spam traps, and returns a clear verification result with a confidence score.

With HaltBounce, you can instantly determine whether an email address is safe to send to — helping you reduce bounce rates, protect your domain reputation, and improve inbox placement.

One invalid email address can lead to high bounce rates. One spam trap hit can harm your deliverability for months. HaltBounce helps prevent these risks before they impact your email campaigns.

Built for developers, marketers, and growth teams who care about reliable email delivery.

## Features

* **Real-time Email Verification:** Instantly check email addresses before sending.
* **Syntax Validation:** Ensures the email address follows proper formatting rules.
* **Disposable Domain Detection:** Identifies temporary or disposable email providers.
* **Role Account Detection:** Detects role-based addresses like `admin@`, `support@`, or `info@`.
* **SMTP Mailbox Verification:** Confirms whether the mailbox exists on the mail server.
* **Detailed Reason Codes:** Provides specific explanations for verification results (e.g., `VALID_SMTP`, `DISPOSABLE_DOMAIN`).
* **Deliverability Score:** Returns a score (0–100) indicating the likelihood of successful delivery.
* **Safe-to-Send Verdict:** Indicates whether it is safe to send emails to the address.

## Use Cases

* **E-commerce:** Prevent fake orders and ensure valid customer contact information during signup or checkout.
* **SaaS Platforms:** Reduce bounce rates and improve onboarding by validating emails at registration.
* **Email Marketing:** Clean mailing lists and improve campaign performance by removing invalid or risky addresses.
* **Lead Generation:** Verify emails collected through forms and landing pages to maintain lead quality.
* **Financial Platforms:** Reduce fraud risks by validating emails during account creation or transactions.

## Visual Examples

The API verifies an email address and returns detailed deliverability insights.

Example input:

`user@example.com`

The API will analyze the address and return information such as:

* Email validity status
* Deliverability score
* Risk indicators
* Reason codes explaining the result

**Valid Email:**

```json
{
  "email": "user@example.com",
  "result": "valid",
  "score": 100,
  "safe_to_send": true,
  "reason_code": "VALID_SMTP",
  "details": {
    "format_valid": true,
    "mx_found": true,
    "smtp_valid": true,
    "is_disposable": false,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "example.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 1200,
    "request_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}
```

**Invalid Email (SMTP rejected):**

```json
{
  "email": "noone@example.com",
  "result": "invalid",
  "score": 0,
  "safe_to_send": false,
  "reason_code": "INVALID_SMTP_REJECTED",
  "details": {
    "format_valid": true,
    "mx_found": true,
    "smtp_valid": true,
    "is_disposable": false,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "example.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 2100,
    "request_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901"
  }
}
```

**Disposable Email:**

```json
{
  "email": "hello@mailinator.com",
  "result": "disposable",
  "score": 0,
  "safe_to_send": false,
  "reason_code": "DISPOSABLE_DOMAIN",
  "details": {
    "format_valid": true,
    "mx_found": false,
    "smtp_valid": false,
    "is_disposable": true,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "mailinator.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 0,
    "request_id": "c3d4e5f6-a7b8-9012-cdef-123456789012"
  }
}
```

## Pricing

*   1 API unit equals 1 email processed.
*   GET requests to the `/api/v1/magicapi/verify/status` endpoint are free and don't count towards API unit usage.
*   Different pricing tiers are available based on usage volume. Please refer to API.market for detailed pricing information.

## API Documentation

### Base URL

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

### Authentication

Authentication is handled via API key. Include your API key in the request header:

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

### Endpoints

#### 1. Verify Email Address

```
GET /api/v1/magicapi/verify/v1/verify
```

Verifies whether an email address is real and deliverable. Performs syntax validation, disposable domain detection, role account detection, and real SMTP mailbox verification. Returns a deliverability score (0-100), a safe_to_send verdict, and a specific reason code explaining the result.

**Parameters:**

| Name    | In    | Required | Type    | Description                  | Example           |
| :------ | :---- | :------- | :------ | :--------------------------- | :---------------- |
| `email` | query | true     | string  | The email address to verify. | `user@example.com` |

**Example Request:**

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

**Example Response (Valid Email):**

```json
{
  "email": "user@example.com",
  "result": "valid",
  "score": 100,
  "safe_to_send": true,
  "reason_code": "VALID_SMTP",
  "details": {
    "format_valid": true,
    "mx_found": true,
    "smtp_valid": true,
    "is_disposable": false,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "example.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 1200,
    "request_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}
```

**Example Response (Invalid Email - SMTP Rejected):**

```json
{
  "email": "noone@example.com",
  "result": "invalid",
  "score": 0,
  "safe_to_send": false,
  "reason_code": "INVALID_SMTP_REJECTED",
  "details": {
    "format_valid": true,
    "mx_found": true,
    "smtp_valid": true,
    "is_disposable": false,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "example.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 2100,
    "request_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901"
  }
}
```

**Example Response (Disposable Email):**

```json
{
  "email": "hello@mailinator.com",
  "result": "disposable",
  "score": 0,
  "safe_to_send": false,
  "reason_code": "DISPOSABLE_DOMAIN",
  "details": {
    "format_valid": true,
    "mx_found": false,
    "smtp_valid": false,
    "is_disposable": true,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": "mailinator.com",
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 0,
    "request_id": "c3d4e5f6-a7b8-9012-cdef-123456789012"
  }
}
```

**Example Response (Syntax Error - No @ Symbol):**

```json
{
  "email": "notanemail",
  "result": "invalid",
  "score": 0,
  "safe_to_send": false,
  "reason_code": "INVALID_SYNTAX_NO_AT",
  "details": {
    "format_valid": false,
    "mx_found": false,
    "smtp_valid": false,
    "is_disposable": false,
    "is_catch_all": false,
    "is_role_account": false,
    "is_free_provider": false
  },
  "meta": {
    "domain": null,
    "provider_used": "enginePrimaryV1",
    "response_time_ms": 0,
    "request_id": "d4e5f6a7-b8c9-0123-defa-234567890123"
  }
}
```

#### 2. Health Check

```
GET /api/v1/magicapi/verify/v1/status
```

Returns the current health status of the API and its verification engines. Does not require authentication.

**Example Request:**

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/verify/v1/status"
```

**Example Response:**

```json
{
  "status": "ok",
  "version": "1.0.0",
  "engines": {
    "enginePrimaryV1": {
      "status": "healthy"
    },
    "engineV2": {
      "status": "healthy"
    }
  }
}
```

## Status Codes

*   `200 OK`: Request successful.
*   `400 Bad Request`: Invalid input parameters or malformed request. Check the error message in the response for details.
*   `401 Unauthorized`: Missing or invalid API key. Ensure the `x-api-market-key` header is present and contains a valid API key.
*   `429 Too Many Requests`: Rate limit or monthly quota exceeded. Check the response headers for rate limit information (e.g., `Retry-After`). If the quota is exceeded, consider upgrading your plan.
*   `503 Service Unavailable`: Service temporarily unavailable. Retry the request after a short delay.

## Rate Limits

The API is subject to rate limits. If you exceed the rate limit, you will receive a `429 Too Many Requests` error. The response may include headers indicating the rate limit and the time until the limit resets. Be sure to handle these errors in your code and implement appropriate retry logic. Contact support for specific rate limit details.

## Error Handling

The API returns errors in JSON format. The error response typically includes an `error` message, an error `code`, and a `request_id` for debugging purposes.

**Example Error Response (Missing Email Parameter):**

```json
{
  "error": "Email parameter is required",
  "code": "MISSING_EMAIL",
  "request_id": "e5f6a7b8-c9d0-1234-efab-345678901234"
}
```

**Example Error Response (Invalid API Key):**

```json
{
  "error": "Unauthorized",
  "code": "AUTH_FAILED",
  "request_id": "b8c9d0e1-f2a3-4567-bcde-678901234567"
}
```

**Example Rate Limit Error Response:**

```json
{
  "error": "Rate limit exceeded",
  "code": "RATE_LIMIT",
  "remaining": 0,
  "reset_at": "2026-03-09T12:00:01.000Z",
  "retry_after_seconds": 1,
  "request_id": "c9d0e1f2-a3b4-5678-cdef-789012345678"
}
```

**Best Practices for Error Handling:**

*   **Check the HTTP status code:** Use the status code to determine the type of error.
*   **Parse the JSON response:** Extract the `error` and `code` fields from the response body to understand the specific error.
*   **Implement retry logic:** For transient errors (e.g., `503 Service Unavailable`, `429 Too Many Requests`), implement retry logic with exponential backoff.
*   **Log error details:** Log the `request_id` and other relevant information to facilitate debugging.

## Implementation Guide

### Example Code

#### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/verify";

async function verifyEmail(email) {
    try {
        const url = `${baseUrl}/v1/verify?email=${encodeURIComponent(email)}`;

        const response = await fetch(url, {
            method: "GET",
            headers: {
                "x-api-market-key": apiKey
            }
        });

        if (!response.ok) {
            const errorBody = await response.json();
            throw new Error(`API error: ${response.status} - ${errorBody.error}`);
        }

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

    } catch (error) {
        console.error("Error during email verification:", error);
        throw error;
    }
}

// Example Usage
async function main() {
    try {
        const result = await verifyEmail("user@example.com");
        console.log("Verification Result:", result);
    } catch (error) {
        console.error("Failed to verify email:", error);
    }
}

main();
```

#### Python

```python
import requests

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

def verify_email(email):
    try:
        url = f"{BASE_URL}/v1/verify?email={email}"
        headers = {
            "x-api-market-key": API_KEY
        }

        response = requests.get(url, headers=headers)

        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json()

    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
        raise

    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        raise

# Example Usage
if __name__ == "__main__":
    try:
        result = verify_email("user@example.com")
        print("Verification Result:", result)
    except Exception as e:
        print(f"Failed to verify email: {e}")
```

#### cURL

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

### Performance Optimization

*   **Cache verification results:** If you are verifying the same email address multiple times, consider caching the results to reduce API calls.
*   **Batch verification:** If you need to verify a large number of email addresses, send them in batches to reduce the overhead of making multiple API calls. (Feature not yet implemented).
*   **Monitor usage:** Track your API usage to identify potential bottlenecks and optimize your integration.
*   **Error Handling:** Implement robust error handling with retries to deal with rate limits or transient errors.

## FAQ

*   **What is the accuracy of the email verification?**
    The API uses multiple techniques to verify email addresses and provides a deliverability score to indicate the confidence level.

*   **What happens if the API is unavailable?**
    If the API is temporarily unavailable, you will receive a `503 Service Unavailable` error. Implement retry logic in your code to handle this scenario.

*   **How do I handle rate limits?**
    If you exceed the rate limit, you will receive a `429 Too Many Requests` error. The response may include headers indicating the rate limit and the time until the limit resets. Implement retry logic in your code to handle rate limits.

## 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.
```

Instantly verify any email address to reduce bounce rates and protect your sender reputation. Free 50 calls/mo, from $39/mo. Start free on API.market.

HaltBounce – Real-Time Email Verification | Free · $39/mo | API.market

Basic