Fix email typos
Catch the slip a format check never sees: ada@gmial.com is flagged as a likely typo and ada@gmail.com is suggested, with a confidence of 0.78, so the person can fix it with one click. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Email address
- ada@gmial.com
- Suggested address
- ada@gmail.com
- Suggestion confidence
- 0.78
catch gmial.com free in your browser
The keyboard slip that costs a customer
Typing gmial.com instead of gmail.com or hotmial.com instead of hotmail.com is one of the most common data-entry errors on the web, and it is invisible to basic format validation because gmial.com is a syntactically perfect domain. Unless someone actually registered it to catch stray traffic, mail sent there simply disappears, and the person who mistyped their own address never receives the welcome email, the password reset or the receipt they were expecting.
A short history of the problem
Typo domains have been squatted on for decades, sometimes by opportunists collecting misdirected mail, sometimes left unregistered entirely so the mail just bounces. Large providers occasionally register their own common misspellings defensively, but smaller regional and business domains almost never do, which is exactly where this kind of check pays off most, catching mistakes that would otherwise vanish silently.
Where it belongs in your stack
Drop it on the blur event of a signup or checkout email field, or run it as a pre-send step in a transactional email pipeline before a welcome message or invoice goes out. Because failed tasks are never billed and retries happen automatically, you can call it on every form submission without worrying about cost creep from transient errors, and combine it with the role and format checks for a fuller picture of address quality.
What you can do with it
Signup form correction
Prompt did you mean gmail.com the moment a user types gmial.com into a registration form, before the account is even created.
Checkout confirmation reliability
Catch a mistyped domain on an order confirmation email address so the receipt and shipping updates actually reach the buyer.
Newsletter opt-in cleanup
Fix likely typos on double opt-in forms so confirmation emails do not silently vanish into nonexistent inboxes.
Password reset delivery
Verify the domain before sending a password reset link, since a bounced reset email often means a locked-out user gives up entirely.
FAQ
Is it free to use?
The tool above runs free in your browser. No subscription, no tokens, and a failed task is never charged.
Does it guarantee the corrected address exists?
No, it flags a plausible typo and suggests the likely intended domain based on similarity, but it does not confirm the corrected mailbox actually exists; pair it with a role or format check for a fuller picture.
Can it catch typos in less common domains?
It is tuned against widely used mail providers, so it is most reliable on major domains; obscure or brand-new domains may not trigger a suggestion.
Can I run it on every signup without worrying about cost?
Yes, since failed tasks are never charged and retries happen automatically up to three times, it is safe to call on every submission.
How does it decide that a domain is a typo?
It compares the typed domain with a list of widely used mail providers, counting how many letters differ and which keys sit next to each other on a keyboard, much like a spell checker. A close match comes back as a suggestion with a confidence score.
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-typo \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"email":"user@gmial.com"}'const res = await fetch("https://api.kit.forhosting.com/verify/email-typo", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"email": "user@gmial.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/verify/email-typo",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"email": "user@gmial.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/verify/email-typo", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"email":"user@gmial.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"email":"user@gmial.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/verify/email-typo", 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": "user@gmial.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "verify.email_typo",
"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
An email typo checker API looks at the domain someone typed and asks whether it is a plausible misspelling of a real, popular provider. It turns a wasted signup or a bounced confirmation email into a caught mistake, right at the moment the address is entered.
How the correction logic works
When it finds a close match it returns a suggestion, such as gmail.com for gmial.com, along with a confidence indicator, so your form can offer a one-click correction instead of silently accepting a broken address. The endpoint compares the submitted domain against a list of widely used mail providers using edit-distance and keyboard-adjacency logic, the same family of technique used in spell checkers, tuned specifically for domain strings rather than dictionary words.
What the response looks like
You send the address, get a task_id back immediately, and receive the verdict through your webhook or a signed link valid for 24 hours. The payload includes whether a likely typo was found, the suggested correction if one exists, and the original input, so your frontend can render a prompt like did you mean gmail.com without guessing at the logic yourself.
Technical questions
What does an email typo checker API actually detect?
It compares the domain part of an address to common, widely used mail providers and flags close misspellings like gmial.com or yahooo.com, suggesting the likely intended domain.
How much does it cost per check?
Each call to /verify/email-typo costs 0.002 dollars, and you are only charged for tasks that complete successfully.
How do I receive the result?
You get a task_id immediately, and the actual suggestion is delivered via your signed webhook or a signed link valid for 24 hours.
How is this different from a format validator?
A format validator only checks the address is structurally valid; this endpoint specifically looks for likely misspellings of real domains that would otherwise pass format validation silently.