Check an email address
Stop obvious typos at the form field: ada@example.com passes as well formed, while an address missing its @ or carrying two dots in a row is caught at once, with no mail server contacted. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Most 'invalid email' complaints trace back to a form that accepted a typo it shouldn't have — a missing @, two consecutive dots, a stray space.
Why email format is trickier than it looks
Most complaints about an invalid email address come from a form that accepted a typo it should have refused: a missing @, two dots in a row or a stray space. The format looks simple, yet it has real edge cases that home-made patterns often get wrong, such as quoted names before the @, plus-addressing, subdomains, domain names in other alphabets and maximum lengths for both the name part and the whole address. A careful check handles these correctly, instead of silently rejecting valid but unusual addresses or letting through broken ones. It looks only at the shape of the address, following the long-standing rules of internet email, and never contacts a mail server, so the answer comes back as fast as a form needs it.
Where it fits and where it stops
Use it on signup and checkout forms to reject malformed addresses the moment they are typed, before they reach your records or trigger a confirmation email. It also works as the first pass over a spreadsheet of addresses, removing garbage entries before you spend time on deeper checks, and when moving data from an old system, flagging broken addresses before they are carried over. Keep in mind that a well-formed address may still not exist. This is the first filter, not the last: pair it with the check that the domain receives mail and with the disposable-address check when you need to know an address is truly reachable.
What the rules actually catch
The email address format looks simple but has real edge cases most hand-written regex gets wrong: quoted local parts, plus-addressing, subdomains, internationalized domain names, and maximum length limits on both the local part and the full address. A dedicated, tested validator handles these correctly instead of silently rejecting valid but unusual addresses or accepting malformed ones a naive pattern would miss.
Built for high-frequency use
Because there's no external lookup involved, this check is fast and predictable, which makes it a natural fit for validating every keystroke-triggered form submission or every row of a CSV import without worrying about rate limits from a third-party mail server getting in the way. That predictability also makes cost easy to forecast at scale, since the price per check never fluctuates with how busy someone else's mail infrastructure happens to be that day.
What you can do with it
Signup and checkout forms
Reject obviously malformed email addresses instantly at the point of entry, before they ever reach your database or trigger a confirmation email.
Bulk list cleanup, first pass
Run a CSV of email addresses through syntax validation to strip out garbage entries before spending time or money on deeper MX or deliverability checks.
Data migration and imports
Flag structurally invalid addresses inherited from a legacy system before they get carried forward into a new database.
FAQ
What email format rules does it follow?
It follows the standard internet email address grammar covering local part, domain, allowed characters, quoting and length limits.
Is there a free plan for email syntax validation?
The tool above runs free in your browser. No subscription, no tokens, and a failed task is never charged.
Is this faster than full email verification with MX checks?
Yes, considerably — there's no network round trip involved, which is exactly why it's suited to real-time form validation.
Can I validate a large batch of addresses?
Yes, since each check is fast, self-contained and independently priced, it fits naturally into bulk import or list-cleanup pipelines.
Does it handle internationalized email addresses?
Yes, the validator accounts for internationalized domain names and the less common but valid address formats, not just the simplest ASCII pattern.
Related tools
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
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/verify/email-syntax \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"email":"ada@example.com"}'const res = await fetch("https://api.kit.forhosting.com/verify/email-syntax", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"email": "ada@example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/verify/email-syntax",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"email": "ada@example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/verify/email-syntax", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"email":"ada@example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"email":"ada@example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/verify/email-syntax", 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": "ada@example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "verify.email_syntax",
"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
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. |
Technical notes
This API checks an address purely against the email format rules, with no DNS lookup and no mailbox probing, so it returns an answer in the time a form field expects one.
What syntax-only really means
There are two very different questions hiding inside 'is this email valid': is it shaped correctly, and does it actually exist. This endpoint answers only the first one, deliberately. It parses the address against the structural rules — local part, @ symbol, domain, valid characters, quoting rules, length limits — the same grammar defined by the long-standing internet email specifications, without ever contacting a mail server.
Why that separation matters
Keeping syntax validation as its own fast, self-contained step means you're not paying the latency or complexity cost of a full mailbox check every time you just need to stop obvious typos. Checking existence requires a DNS and often an SMTP round trip, which is slow, occasionally blocked by receiving servers, and overkill for a signup form that just needs to reject '<user>gmailcom' before the request even leaves the browser's origin.
Where it belongs in your stack
This is the first filter, not the last one — pair it with the MX-lookup and disposable-email checks when you need to know an address is truly reachable and not a throwaway, and use this endpoint alone when you just need a fast, cheap, no-network gate on a form or a bulk import. It's the right tool for real-time input validation, not for auditing a mailing list's deliverability.
Integration use cases
API input sanitization
Validate email fields on any endpoint that accepts user-submitted contact information, independent of whether you'll ever actually email that address.
Technical questions
Does this email syntax validation API check if the mailbox actually exists?
No, by design. It validates structure only, with no DNS or SMTP lookup; use the MX-lookup endpoint if you need to confirm the domain can actually receive mail.
How much does one syntax check cost?
$0.002 per request, charged only when the task completes successfully.
How do I get the validation result?
The task runs asynchronously: a task_id returns immediately, and the result follows via a signed webhook or a signed link valid for 24 hours.