ForHosting KIT · Validation

Verify an email exists

A syntactically perfect email address is worthless if its domain has no mail server behind it — a mistyped company domain or an expired one will pass a regex and still bounce every message you send. This API checks syntax, resolves the domain, and looks up its MX records in a single call, telling you whether mail could realistically be delivered there.

● StablePer request + per item$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Three checks, one answer

Email verification worth trusting has to clear three separate hurdles: the address must be structurally valid, the domain after the @ must actually exist and resolve, and that domain needs mail exchange (MX) records pointing to a server willing to accept messages for it. A domain can exist and serve a perfectly good website while having zero MX records — meaning it simply cannot receive email — and that gap is exactly what a syntax-only check will never catch.

What MX records are, briefly

MX records are DNS entries that tell the rest of the internet which mail servers handle incoming messages for a domain, each with a priority value so a backup server can take over if the primary is unreachable. They've been part of how internet email routes messages since the early DNS-based mail systems replaced older host-file-based delivery, and checking them is the standard way to confirm a domain is actually mail-capable without attempting to send anything.

What this endpoint does not do

This is domain-level verification, not mailbox-level — it confirms the domain can receive mail in principle, not that a specific inbox exists or is currently accepting messages, which would require an SMTP handshake that many receiving servers deliberately block or fake out to prevent enumeration. Combine it with disposable-email detection when you also need to filter out throwaway domains rather than just confirm deliverability plumbing.

Where it earns its cost

This check matters most right before an email actually leaves your system: gating a signup so a transactional welcome email doesn't immediately bounce, cleaning a list before a campaign send to protect sender reputation, or validating a B2B lead form where a fabricated company domain is a common way bad actors slip through. It costs more than a pure syntax check because it does real DNS work, and that's exactly the tradeoff worth making at these moments.

How it behaves as an async task

Like every task in the API, this one runs asynchronously against our global edge: you get a task_id back immediately and the syntax, domain and MX results arrive together via a signed webhook or a signed link, so a slow or unresponsive DNS lookup on one address never blocks the rest of your pipeline.

What you can do with it

Transactional email gating

Verify an address can receive mail before triggering a welcome or confirmation email, cutting down on immediate hard bounces.

Marketing list hygiene

Screen a subscriber list for domains with no MX records before a campaign send, protecting sender reputation with mailbox providers.

B2B lead qualification

Catch fabricated or nonexistent company domains submitted on a sales lead form, a common pattern in low-quality or fraudulent submissions.

Account recovery flows

Confirm a user-supplied recovery email domain is actually mail-capable before relying on it as the only path back into an account.

FAQ

What does the email verification API actually check?

Three things in one call: address syntax, whether the domain resolves, and whether it has valid MX records pointing to a mail server.

Does this confirm a specific mailbox exists?

No, it verifies at the domain level via MX records, not by contacting a specific mailbox — that would require an SMTP handshake many servers block.

How is this different from the syntax-only email check?

Syntax checking never touches the network; this endpoint additionally does real DNS resolution and MX lookup, so it costs more but tells you a domain can actually receive mail.

Is there a free version of this email verifier?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

What's the price per verification?

$0.002 per request, and you're billed only when the task completes successfully.

How fast do I get results?

The task is asynchronous: a task_id returns immediately and the full result follows via signed webhook or a signed link valid for 24 hours.

Can I use this to clean an entire mailing list?

Yes, it's commonly run across a full list before a campaign to strip out addresses whose domains have no mail routing at all.

What happens if the domain's DNS is temporarily unreachable?

The task retries automatically up to three times before returning a clear error, and a failed task is never charged.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/verify/email-mx

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/verify/email-mx \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"email":"[email protected]"}'

const res = await fetch("https://api.kit.forhosting.com/verify/email-mx", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "email": "[email protected]"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/verify/email-mx",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "email": "[email protected]"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/verify/email-mx", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"email":"[email protected]"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"email":"[email protected]"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/verify/email-mx", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "email": "[email protected]"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "verify.email_mx",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →