ForHosting KIT · Validation

Fix email typos

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.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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.

How the correction logic works

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. 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.

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.

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

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.

Is it free to use?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

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.

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.

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.

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 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.

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-typo

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-typo \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"items":["valor-1","valor-2"]}'

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({
    "items": [
      "valor-1",
      "valor-2"
    ]
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "items": [
        "valor-1",
        "valor-2"
    ]
},
)
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" => &#39;{"items":["valor-1","valor-2"]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"items":["valor-1","valor-2"]}`)
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

{
  "items": [
    "valor-1",
    "valor-2"
  ]
}

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

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 →

Run — free