GLOBUS.App

Email Checker API — Check Email Format and Server Existence for Developers

Email Checker API — Check Email Format and Server Existence

Two Levels of Email Validation

Most applications validate email addresses at the format level — checking that the string contains an @ symbol, a domain, and a top-level domain. This catches obvious typos but misses a much larger class of problems: addresses that are syntactically correct but point to domains with no mail server, mailboxes that do not exist, or accounts that were deleted after signup. A user who types john.doe@gmial.com passes a regex check but will never receive your confirmation email.

The Email Checker API by GLOBUS.studio performs both checks in a single request: first it validates the address format against standard email syntax rules, then it connects to the domain’s mail server via SMTP to verify that the specific mailbox exists. The response indicates one of three states — invalid, exists, or does not exist — in plain text or JSON, with an average latency of 25ms.

API Endpoint and Parameters

GET https://api.globus.studio/v2/email?email={address}&format={format}
  • email — the email address to validate
  • format — response format: json or plain

Full parameter reference and live testing are available on the Email Checker API documentation page.

Response States and Examples

Valid and Existing Address — JSON

GET /v2/email?email=example@example.com&format=json

{
  "status": "exists",
  "message": "Email exists"
}

Invalid Format — JSON

GET /v2/email?email=invalid-email&format=json

{
  "status": "invalid",
  "message": "Invalid email format"
}

Valid Format but Nonexistent Mailbox — Plain Text

GET /v2/email?email=nonexistent@example.com&format=plain

Email does not exist

How the Server-Side Check Works

After passing format validation, the API performs an SMTP handshake with the mail exchanger (MX) record associated with the email’s domain. It queries the domain’s MX records via DNS, opens a connection to the mail server, and issues a RCPT TO command with the target address. The server’s response — accepted or rejected — determines whether the mailbox exists. No email is ever sent; the connection is closed immediately after the verification step. This method catches the majority of nonexistent addresses on cooperating mail servers, though some providers deliberately return accepting responses for all addresses as an anti-scraping measure.

Common Use Cases

Registration and Signup Forms

The most impactful place to deploy email validation is at the point of account creation. Verifying the address before writing the user record to the database prevents orphaned accounts, reduces bounce rates on transactional email, and eliminates a common path for fake registrations. A does not exist response lets the form display a specific error — «this mailbox was not found, did you mean a different address?» — rather than the generic post-signup «check your inbox» message that silently fails for days.

Lead Generation and CRM Enrichment

Sales and marketing pipelines accumulate email addresses from contact forms, event registrations, and CSV imports. Before adding a new lead to a CRM or email sequence, validating the address via API filters out undeliverable contacts before they pollute sender reputation. Running validation at ingestion is significantly cheaper than discovering bounce rates after a campaign has already been sent to a degraded list.

Bulk List Cleaning

Mailing lists decay over time: users change employers, abandon addresses, or close accounts. A periodic validation pass over an existing subscriber list — iterating via script and flagging addresses that return does not exist — keeps the active list clean and protects the sending domain’s reputation with email service providers. Even a modest reduction in hard bounces has measurable effects on deliverability scoring.

WordPress Plugin Development

Contact form plugins, membership plugins, and WooCommerce checkout flows all collect email addresses at critical moments. A lightweight call to the Email Checker API via wp_remote_get() during form submission — before the data is committed to the database or passed to an email marketing integration — adds a server-side validation layer that JavaScript-only checks cannot provide. The plain-text response format makes the result trivial to evaluate in PHP without JSON decoding.

Transactional Email Pre-Flight

Systems that send high-value transactional emails — password resets, order confirmations, invoice delivery — can validate (with email checker) the destination address immediately before dispatch. If the API returns does not exist, the system can surface an address-update prompt to the user or route the notification through an alternative channel, rather than silently dropping the message into a bounce queue.

Anti-Abuse and Disposable Address Detection

Many disposable email services generate addresses that are syntactically valid and may even pass a basic MX check, but the server-side SMTP handshake reveals whether the specific mailbox is active. Combining the API’s existence check with a blocklist of known disposable domains gives abuse prevention logic two independent signals, reducing false negatives compared to either approach alone.

Support Ticket and Helpdesk Systems

Helpdesk platforms that create tickets from inbound email or web forms need a reliable reply address for every ticket. Validating the submitter’s email at ticket creation time — and flagging tickets where the address does not exist — prevents agents from composing detailed responses that will never be delivered, and prompts them to seek an alternative contact method while the conversation is still active.

Integration Examples

cURL

curl "https://api.globus.studio/v2/email?email=example@example.com&format=json"

JavaScript (Fetch API)

const email = 'example@example.com';
const res   = await fetch(
  `https://api.globus.studio/v2/email?email=${encodeURIComponent(email)}&format=json`
);
const data  = await res.json();

if (data.status === 'exists') {
  // proceed with registration
} else {
  // show error to user
  console.warn(data.status, data.message);
}

PHP

$email    = 'example@example.com';
$url      = 'https://api.globus.studio/v2/email?email=' . urlencode($email) . '&format=json';
$response = json_decode(file_get_contents($url), true);

if ($response['status'] === 'exists') {
    // safe to proceed
} else {
    echo $response['message'];
}

Python

import requests

data = requests.get(
    'https://api.globus.studio/v2/email',
    params={'email': 'example@example.com', 'format': 'json'}
).json()

print(data['status'], data['message'])

WordPress (PHP) — Form Submission Hook

function validate_email_via_api( $email ) {
    $url      = add_query_arg(
        [ 'email' => rawurlencode( $email ), 'format' => 'json' ],
        'https://api.globus.studio/v2/email'
    );
    $response = wp_remote_get( $url );
    $data     = json_decode( wp_remote_retrieve_body( $response ), true );
    return $data['status'] ?? 'invalid';
}

// Usage in a form handler:
$status = validate_email_via_api( $_POST['email'] );
if ( $status !== 'exists' ) {
    wp_send_json_error( [ 'message' => 'Please provide a valid, reachable email address.' ] );
}

Understanding the Three Response States

Building robust handling around all three possible statuses — rather than treating only exists as actionable — produces significantly better user experiences:

  • invalid — the address failed format email Checker before any server contact was attempted. The user made a syntax error. Show a specific format hint immediately.
  • exists — format is valid and the mail server confirmed the mailbox is active. Safe to proceed with registration, list addition, or message dispatch.
  • does not exist — format is valid but the mailbox was not found on the server. Prompt the user to double-check the address rather than flagging it as a hard error — some mail servers reject SMTP probes by policy even for valid addresses.

Performance

The 25ms average latency reflects the real-world cost of the SMTP handshake with an external mail server — an irreducible network operation that no local library can replicate. For synchronous form validation, 25ms is imperceptible to users. For bulk list processing, parallelizing requests across multiple workers scales throughput linearly. Caching results by email address with a short TTL (one hour is typical) eliminates redundant checks for addresses that appear multiple times in a processing batch.

Test all response states live and review the full field reference on the Email Checker API documentation page.

GLOBUS.App

GLOBUS.studio