ForHosting KIT · Validation

Check an email address

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

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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

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 'gmailcom' before the request even leaves the browser's origin. 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.

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.

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.

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.

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.

Data migration and imports

Flag structurally invalid addresses inherited from a legacy system before they get carried forward into a new database.

FAQ

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.

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. 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 one syntax check cost?

$0.002 per request, charged only when the task completes successfully.

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.

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.

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.

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

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-syntax \
  -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-syntax", {
  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-syntax",
    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-syntax", 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-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

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

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

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