---
title: "Real-Time Email Verification for Signup Forms | Emvero"
description: "Check an address during signup or checkout. Use the API status and action, or poll a pending result before your form makes its decision."
url: https://emvero.io/real-time-email-verification/
language: en
updated: 2026-10-07
---

Real-time email verification

# Verify email addresses during signup

Check an email address before completing a signup, checkout or lead form. Your server sends the address to Emvero, then uses the result to let the person continue, require email confirmation or ask them to correct it.

Some checks finish in the first response; others need more time. Set a limit on how long the form waits and choose what happens if the result is still pending.

Start for free

View documentation

Server-side API · No verification email sent · Retrieve pending results

## Send the address from your server

Create and confirm an Emvero account, then create an API credential. Your browser can check the address format, but your server sends the verification request and keeps the credential out of browser code.

The request below uses the default full check. It checks the address format, domain and mail route, and may ask the receiving server about the recipient when the server permits it. A full check costs at most 10 credits.

```
curl -sS https://api.emvero.tech/v1/verifications \
  -H "Authorization: Bearer emv_your_credential" \
  -H "Content-Type: application/json" \
  -d '{"email":"ada@example.com"}'
```

The response includes an `id` to retrieve the result, a `status`, a recommended `action`, individual `checks` and `reason_codes`. These selected fields illustrate a possible result; they are not a measurement of `example.com`:

```
{
  "id": "5f0b6f3e-1a4c-4a1f-9d2e-8f7b3c2a1d90",
  "status": "risky",
  "action": "allow_with_email_confirmation",
  "checks": { "syntax": "valid", "mail_routing": "valid", "accept_all": "yes" },
  "reason_codes": ["ACCEPT_ALL_DOMAIN"]
}
```

In this example, the domain accepts arbitrary recipient names: it has catch-all behaviour. That leaves the existence of a particular mailbox uncertain, so the result is `risky` and recommends `allow_with_email_confirmation`. Another risky result may recommend a different action. Your application can follow the recommendation or apply its own rules to the check findings and reasons. The [email verification API](https://emvero.io/email-verification-api/) page explains the complete response.

## Use the result to decide what the form does

Completed checks return one of four statuses: `deliverable`, `risky`, `undeliverable` or `unknown`. The `action` field gives Emvero’s recommendation for handling the address. If the status is `pending`, the check is still running and the form needs to wait or follow its fallback policy.

| Action or status | Suggested form behaviour |
| --- | --- |
| `allow` | Let the person continue with the address. |
| `allow_with_email_confirmation` | Let them continue, but require email confirmation to establish mailbox control. |
| `reject` | Ask them to correct the address or provide another one. |
| `pending` | Wait for a result up to your form’s deadline, then use your chosen fallback if it is still pending. |

The first three rows are exact `action` values; `pending` is a status indicating work in progress. A completed `unknown` result means the evidence could not establish whether the address can receive mail. Keep that uncertainty visible rather than marking the address invalid.

The `confidence` field is an evidence score from 0 to 1. It is not a probability of delivery. Use the recommended action and reasons to make your decision, rather than treating the score as a delivery guarantee.

Show a correction prompt while the person can still edit the address. The [signup-form validation guide](https://emvero.io/guides/signup-form-validation/) explains how browser checks, backend verification and confirmation fit into the form.

## When the result is still pending

The receiving server may take time to respond or temporarily limit requests. If the check cannot finish in the first response, Emvero returns `pending`, an identifier and a suggested wait in milliseconds. This illustrative response asks you to wait two seconds:

```
{
  "id": "5f0b6f3e-1a4c-4a1f-9d2e-8f7b3c2a1d90",
  "status": "pending",
  "retry_after_ms": 2000
}
```

After the interval, request `GET /v1/verifications/{id}` with the same bearer credential. If the result is still `pending`, wait for the new interval before retrieving it again. Emvero does not send a callback; your server must retrieve the result.

Set a deadline for the form and tell the person what happens if the check is still pending when it is reached. For signup, you can continue registration while requiring email confirmation before granting access, and finish verification in the background. If the step needs a completed check, keep it on hold and explain what happens next. A timeout or API error leaves the address unresolved; it is not an `undeliverable` result. The [pending-result documentation](https://docs.emvero.io/using/pending/) explains how to retrieve the result.

## When you still need email confirmation

A full check can ask the receiving mail server about the address through SMTP, the protocol used to transfer email. The connection stops before the message stage, so verification sends no email. A domain check stops at address format and domain evidence without making an SMTP connection. It costs 2 credits and cannot establish that a particular mailbox exists.

A server’s response can leave the mailbox’s existence uncertain, and even an accepting response does not guarantee future delivery. Email confirmation answers a separate question: whether the person can receive your confirmation message and act on it. Use it when control of the mailbox matters.

Verification also does not establish the person’s identity or assess bots, repeated signups or fraud. Those need separate controls. For addresses already stored in your system, [bulk verification](https://emvero.io/bulk-email-verification/) uses the same API and result fields in a script or job you run.

Questions

## Frequently asked.

**What is real-time email verification?**

It checks an email address while someone submits a signup, checkout or lead form. Your server sends the address to the API so your form can use the result before completing the submission. Real-time describes when you request the check; it does not promise an immediate answer.

**How do I verify an address during signup?**

Create an API credential in your confirmed Emvero account and keep it on your server. Call the API before finalising signup, then read `status` and the recommended `action`. If the check is still pending, keep retrieving the result until your form's deadline and use your chosen fallback if it has not finished.

**What should the form do when the result is pending?**

Wait the number of milliseconds given in `retry_after_ms`, then request `GET /v1/verifications/{id}`. If the result remains pending, repeat until your form's deadline. At that point, your application can require email confirmation before granting access or hold the step until a result is available. Reaching the deadline does not establish that the address is invalid.

**Does the check send a verification email?**

No. A full check may ask the receiving mail server about the recipient through SMTP, but the connection stops before `DATA`, the message stage. Your application sends its own confirmation email when you need to establish that the person controls the mailbox.

**Will it stop fake signups?**

It can identify malformed addresses, mail-routing problems and domains listed as temporary-mail providers. Those findings do not identify the person submitting the form or prove abuse. Use separate controls for bots, repeated signups and fraud.

## Compared side by side

### Real-time vs. bulk verification

The same checks and the same four verdicts, in two shapes. Real-time answers one address while somebody waits; bulk works through a list you already have.

### Greylisting

A receiving-server policy that temporarily defers an unfamiliar SMTP attempt; a later attempt may pass.

Add a check to your form

## Test how your form handles each result

Confirm a new account to receive 1,000 credits without a card. That covers 100 full checks or up to 500 domain checks. Use them to test your form's decisions and what happens when a check is still pending.

Start for free

Contact sales