# Verify a single address

> Verify one email address in the dashboard or with the API, choose between fast and full mode, and use verification to catch bad addresses at sign-up.

This guide shows how to check one email address, either by hand in the dashboard or from your code with the API. It also covers using verification in a sign-up form to stop typos and throwaway addresses before they reach your list.

## Before you begin

- Each verification costs 5 credits. Check your balance in the sidebar or in **Workspace → Billing**.
- For the API, use an API key with **Full Access**. Sending-only keys can't verify addresses.

## Fast and full mode

| Mode | Checks | Use it for |
| --- | --- | --- |
| `fast` (default) | Syntax, MX records, domain age, disposable, role, free-provider and random-looking addresses | Sign-up forms and anything a person is waiting on. |
| `full` | Everything in `fast`, plus a connection to the recipient's mail server to check the mailbox: deliverable, disabled, inbox full and catch-all | Cleaning addresses before an important send, when a few extra seconds don't matter. |

Both modes cost the same. `full` takes longer because it talks to the recipient's mail server, which can be slow or refuse to answer. Some large providers block these checks, so `full` can't always confirm a mailbox. See [Verification results](/docs/email-verification/results/) for what each check means.

## Verify an address

**Dashboard**

  1. **Open Email Verification.** Go to **Email Verification → Emails** and select **Verify Email**.

  2. **Enter the address.** Type it into **Email** and select **Verify Email**. The dashboard uses `fast` mode.

  3. **Open the result.** The address appears in the list with its **Status**, **Result**, **Risk**, **Score**, **Created** date and days until it's **Expiring**. Select it to see every individual check, such as **Valid Syntax**, **Disposable**, **Role Account** and **Has MX Records**.

  To check many addresses at once, [verify a list](/docs/email-verification/lists/) instead.

**API**

  Call [Verify an address](/docs/api-reference/email-verifications/verify/) with the address and, optionally, the mode:

```bash
curl https://api.emailit.com/v2/email-verifications \
  -X POST \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "email": "ada@example.com", "mode": "full" }'
```

  The result comes back in the response:

```json
{
  "id": "ev_6Hq2Lm9Tx4Pz",
  "object": "email_verification",
  "email": "ada@example.com",
  "status": "completed",
  "score": 100,
  "risk": "low",
  "result": "safe",
  "mode": "full",
  "checks": {
    "valid_syntax": true,
    "disposable": false,
    "role_account": false,
    "inbox_full": false,
    "deliverable": true,
    "disabled": false,
    "free_email": false,
    "gibberish": false,
    "catch_all": false,
    "smtp_connect": true,
    "has_mx_records": true,
    "domain_age": 10957
  },
  "address": {
    "mailbox": "ada",
    "domain": "example.com",
    "suffix": null,
    "root": "ada@example.com"
  },
  "did_you_mean": null,
  "mx_records": [
    { "priority": 10, "exchange": "mx1.example.com" }
  ],
  "created_at": "2026-10-01T10:24:11Z",
  "updated_at": "2026-10-01T10:24:11Z"
}
```

  In `fast` mode, the mailbox checks (`deliverable`, `disabled`, `inbox_full`, `catch_all` and `smtp_connect`) are `null` because they weren't tested.

  | Status | When |
  | --- | --- |
  | `200` | The address was verified. This includes badly formed addresses, which come back with `result: "invalid"`. |
  | `400` | `email` is missing, or `mode` isn't `fast` or `full`. |
  | `402` | The workspace has fewer than 5 credits. |

  Every successful verification also fires an `email_verification.created` event. See [Webhook event types](/docs/webhooks/event-types/).

## Verify addresses at sign-up

Checking an address when someone types it is the cheapest way to keep a list clean. A typo caught at sign-up never becomes a bounce.

1. **Call the API from your server.** Never put your API key in browser code. Send the address from your sign-up handler, in `fast` mode.

2. **Set a timeout and fail open.** If verification is slow or returns an error, let the sign-up through. Losing a real customer costs more than one bad address.

3. **Act on the result.** Block what's clearly wrong, suggest fixes for typos and let everything else through.

```javascript title="verify-signup.js"
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 5000);

  try {
    const res = await fetch('https://api.emailit.com/v2/email-verifications', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email, mode: 'fast' }),
      signal: controller.signal,
    });
    if (!res.ok) return { ok: true }; // fail open

    const verification = await res.json();

    if (verification.result === 'invalid') {
      return {
        ok: false,
        message: verification.did_you_mean
          ? `Did you mean ${verification.did_you_mean}?`
          : 'Please check your email address.',
      };
    }
    if (verification.result === 'disposable') {
      return { ok: false, message: 'Please use a permanent email address.' };
    }

    // Accept the address, but offer a correction if one looks likely.
    return { ok: true, suggestion: verification.did_you_mean };
  } catch {
    return { ok: true }; // timeout or network error: fail open
  } finally {
    clearTimeout(timer);
  }
}
```

A few tips:

- **Use `did_you_mean`.** For common domain typos, such as `ada@gmial.com`, it contains the likely address, `ada@gmail.com`. Show it as a suggestion the person can accept.
- **Don't block role addresses outright.** `info@` or `sales@` is often how small businesses sign up. Flag them instead.
- **Verify once per address.** Each call costs credits, so verify when the form is submitted, not on every keystroke, and store the result.

## Related

  - [Verification results](/docs/email-verification/results/): What every result, risk and check means.
  - [Verify a list](/docs/email-verification/lists/): Check up to 10,000 addresses at once.

---
Source: https://emailit.com/docs/email-verification/single/