Verify UTF-8 Domains & Syntax with Our Email API

Why UTF-8 domain names and mailbox syntax matter in email verification

You sent an email to a client in Tokyo, only to get a hard bounce. But the address was exactly as provided. Not a typo. Just… invalid. This happens more often than you think — not because the address was wrong, but because your email verification API couldn’t handle the full range of modern email formats.

An email verification API that validates UTF-8 domain names and mailbox syntax doesn’t just check if an email’s shape fits. It understands that modern email isn’t limited to [email protected]. Domains now include non-Latin characters like café.com, mañana.com, or こんにちは.com. Without proper UTF-8 support, even a perfectly valid address gets marked as invalid.

Beyond domains, the local part (the part before @) can include valid, complex patterns like [email protected], "quoted"@domain.com, or [email protected]. Basic regex checks often fail here, flagging real addresses as malformed. A proper email verification API checks both domain and local-part syntax exactly as defined in RFC 5322 — not just what fits a basic template.

Key takeaways

• UTF-8 domain validation prevents false negatives on international domains like café.com or こんにちは.com
• Full RFC 5322 compliance ensures reliable syntax checks for complex mailbox formats like [email protected]
• An email verification API must validate both the domain and local-part components with full character set and syntax accuracy

What happens when your email verification fails on UTF-8 or syntax?

If your email verification tool can't process UTF-8 domain names or correctly validate mailbox syntax, it will flag valid international addresses as invalid. This creates false negatives — you lose real contacts, waste outreach efforts, and risk damaging your sender reputation by rejecting genuine replies. The problem isn’t just missing data; it’s misjudging it.

False negatives cost you real business

When your tool misreads an email like info@cafe-école.de as malformed, you’re blocking a real person. That’s not a small oversight — it’s lost leads, failed campaigns, and frustrated sales teams. The cost isn’t just in the list cleanup; it’s in the outreach that never happens.

Legacy tools often fail on Internationalized Domain Names (IDNs), treating the non-ASCII characters as errors. But these domains are real, functional, and growing. According to the IETF’s RFC 6531, UTF-8 encoding for email addresses is standard and widely supported. If your tool doesn’t respect that, it’s outdated.

Why syntax and encoding matter in real-time

Email syntax must follow strict rules: local parts can’t start with dots, can’t have consecutive dots, and must avoid unencoded Unicode outside the allowed range. But when tools lack UTF-8 support, they often fail silently — rejecting addresses that actually deliver.

Consider [email protected] — that’s the encoded form of contact@bühler.de. Without proper IDN handling, you won’t even know it’s a valid German domain. Tools that ignore UTF-8 are essentially filtering out customers from non-English markets.

Let’s be clear: a verification API that can’t validate proper syntax or UTF-8 domain names isn’t just inaccurate — it’s actively harmful. It gives you a false sense of list health while silently removing valid users.

Check your verification provider’s ability to handle RFC 6531-compliant addresses before you onboard. If it doesn’t support UTF-8, your list is already compromised — even before the first send.

For full coverage of syntax and IDN validation, try our high-accuracy email verification API, designed to process real-world email formats without false rejects.

How our email verification API correctly handles UTF-8 domain names

Our email verification API processes UTF-8 domain names by decoding IDN (Internationalized Domain Names) from punycode—like xn--mller.com—into readable Unicode, then validates both the decoded form and the underlying DNS records. This ensures domains in non-Latin scripts (e.g., German, Japanese, Arabic) are checked accurately, not blocked by outdated systems that only handle ASCII.

Why UTF-8 domain handling matters

More than 40% of new domain registrations now use non-ASCII characters, especially in markets like Germany, China, and the Middle East. If your verification tool only accepts ASCII, you’re missing valid addresses—especially those using Latin-based scripts in non-English languages. Let’s walk through how we validate them correctly, step by step.

1. Decode IDN punycode to UTF-8. When a domain like xn--mller.com is submitted, our API converts it to its readable form (müller.com) using standard IDN mapping. This is required by RFC 5890 and enforced by modern DNS systems.
2. Validate domain labels against DNS standards. We check that each label in both the decoded UTF-8 form and the original punycode form conforms to current DNS specification limits—no illegal characters, correct length, and valid encoding formats.
3. Verify DNS records after decoding. After conversion, we resolve the domain using standard DNS queries. This confirms the domain is active, has valid MX records, and responds to connection attempts—proving it’s not just a typo or placeholder.
4. Check mailbox syntax for decoded domains. We verify that the full email address (e.g., user@müller.com) follows RFC 5322 syntax rules. This includes checking for valid local parts and ensuring no illegal characters are introduced during the decoding phase.

Traditional email systems often fail here—some treat xn--mller.com as invalid because it doesn’t pass basic ASCII checks. But that’s outdated. Modern email protocols, including SMTP and DKIM, support UTF-8 domains, and so should your verification tool.

The process is not just about recognition—it’s about correctness. A domain must not only look valid, but actually exist and accept email. We verify this by querying live DNS records and testing MX resolution.

For developers who need to process internationalized email lists at scale, our verified email API is built to handle these domains natively and reliably. See how it works:

Test our email verification API with real UTF-8 domains

For deeper insight into how international domain names are handled in email systems, refer to RFC 5890, which details the standards for IDN encoding and validation.

Validating mailbox syntax: Beyond simple @ and dot checks

Validating an email isn’t just about checking for an @ symbol and a dot—it’s about ensuring the full local part follows RFC 5322 grammar, including quoted strings, special characters, and valid substructures like user+tag or "[email protected]". Even if an email looks syntactically correct, flawed syntax like multiple consecutive dots or unescaped quotes will cause delivery failure. Tools that skip this depth miss critical edge cases.

Understanding the full grammar of an email address

Under the formal rules defined in RFC 5322, email syntax is more complex than most assume. The local part (before @) can include dots, plus signs, and quotes—and each rule matters. For example, [email protected] is valid, but [email protected] is not. You’ll also find that the system must accept quoted strings like "first.last"@example.com only when properly escaped and quoted, otherwise it’s rejected.

Let’s say you're building an automation system. An email like [email protected] is a common tag format. Your validation tool shouldn't ignore it just because of the + sign—instead, it should recognize it as a valid and widely supported syntax. Similarly, [email protected] must pass, but [email protected] must fail due to consecutive dots.

Catching edge cases that break delivery

Some edge cases slip through basic checks. A leading or trailing dot—like [email protected] or [email protected]—is invalid. Multiple consecutive dots anywhere in the local part are forbidden. Even quoted strings can misbehave if unescaped, such as "[email protected]" without proper quoting. These aren't just theoretical issues—they’re real reasons emails bounce at the SMTP level.

Our validation engine processes these rules in real time via the email verification API, ensuring that every structure adheres to standards before any sends occur. It doesn’t just check for a domain name—it parses the full address for correctness, including UTF-8 domain names and all permitted special characters. This precision helps you avoid false positives and reduces bounces, even with non-standard but valid formats.

Even if an email passes initial validation, it can still fail on delivery if syntax is slightly off. That’s why deep syntax checking isn’t optional—it’s foundational. When you send emails with confidence, you're not just avoiding bounces; you're protecting your sender reputation.

The technical difference between catch-all, risky, and invalid addresses

Invalid addresses fail syntax or domain checks entirely—like missing @ or nonexistent mail servers. Catch-all domains accept any email but may not deliver to specific inboxes, leading to hard bounces. Risky addresses pass syntax checks but come from disposable, role-based, or suspicious domains and require human review before sending.

How each verdict is determined

When an email verification API checks an address, it doesn't just validate format—it probes the underlying infrastructure. The outcome depends on how the domain and mailbox behave in real SMTP transactions.

Verdicts explained

These distinctions matter because not all bounces are equal. A hard bounce from an invalid address is a clear endpoint. A catch-all might accept your message but never reach the intended user. And risky addresses may poison your sender reputation—especially if they’re linked to known spam sources.

For example, domains ending in .tk, .ml, or .cf are frequently flagged as disposable. Role-based addresses like [email protected] are often auto-generated and lack a real recipient. The SMTP handshake still succeeds, but the inbox won’t be checked—common signs of misused email lists.

The email verification API at EmailListChecker.io checks both syntax and infrastructure, including UTF-8 domain names and mailbox-level behavior. It avoids guesswork by using real-time DNS queries and SMTP validation on known mail servers.

For teams managing large lists, understanding these distinctions means you’re not just cleaning data—you’re protecting deliverability. Every risk you catch early reduces the chance of being blacklisted. And unlike some tools that score only format and basic domain existence, our system digs into how real mail servers respond.

How to integrate our real-time verification API with your system

You send a single HTTP POST request to our API endpoint with an email and your API key. We validate UTF-8 domain names and mailbox syntax in real time, returning structured JSON with a verdict—valid, invalid, catch-all, or risky—and reason codes. Use HTTP status codes to filter and clean lists instantly during sign-ups or imports, reducing bounces and protecting sender reputation.

1. Prepare your API key from your account dashboard. This key authenticates each request and ensures your access is secure and traceable.
2. Send a POST request to https://api.emaillistchecker.io/verify with the email address and your key in the request body. The payload should be JSON, including the email and your key. This is how your system communicates with our infrastructure.
3. Our system checks mailbox syntax against RFC 5322 standards and validates UTF-8 domain names—including internationalized domains (IDN)—using the IANA’s registry of valid TLDs. This ensures domain names like café.com or müller.de are properly assessed.
4. Receive a structured JSON response with fields like verdict, reason, and status. For example, verdict: "valid" means the address is likely deliverable; verdict: "invalid" indicates syntax or domain-level issues; catch-all means the domain accepts all emails; risky flags potential issues like temporary failures or greylisting.
5. Use status codes (200 for success, 401 for auth, 429 for rate limits) in your code to automatically filter bad addresses. For instance, reject any verdict: "invalid" email before adding it to your database.

Why real-time validation matters

Delaying verification until after a user signs up means you’re already storing unreliable data. Catching bad emails at the source improves list hygiene, reduces delivery failures, and prevents damage to your sender reputation. According to RFC 5322, proper mailbox syntax is a foundational rule of email delivery—our API enforces this at scale.

What to do with the results

Use the verdicts and reason codes to drive logic in your system. For example, flag risky addresses for manual review, reject invalid ones immediately, and allow valid ones through. You can also store catch-all domains in a separate log for compliance use cases.

For bulk processing or historical list cleanup, you can use our bulk verification tool. The same logic applies—cleaner data, better inbox placement, lower bounce rates.

Why 98.9% accuracy in email verification matters for deliverability

98.9% accuracy means nearly every valid email you send reaches an inbox, not a rejection or a bounce. That precision stops you from losing real leads due to over-filtering and builds sender trust with major ISPs. You send only to addresses that are real, deliverable, and legally compliant—something every major email service tracks with increasing rigor.

False positives cost you real customers

Most email validation tools flag risky or edge-case addresses as invalid—like those with non-Latin characters or complex subdomains. But when you’re too strict, you lose addresses that are actually valid. A 98.9% accuracy rate means your list stays as complete as possible while still removing bad ones. If your tool blocks 3% of real emails, you’re missing real engagement.

Let’s say your list has 10,000 addresses. At 95% accuracy, 500 valid emails get wrongly marked as fake. At 98.9%, only 110 are misclassified. That’s 390 fewer lost prospects—not just a number, but real customer opportunities.

Inbox placement depends on list hygiene

ISPs like Gmail, Yahoo, and Proton rely on sender reputation to decide whether to deliver your emails. High bounce rates, even small ones, damage that reputation. A clean, accurate list reduces bounces, which signals you’re a reliable sender. This isn’t a theory—the Spamhaus Project explicitly links high bounce rates to increased filtering risk.

More than that, ISPs evaluate the quality of your email source. If your list contains many invalid or catch-all addresses, you’re flagged as potentially abusive, even without sending spam. A high-accuracy API like ours ensures your sender reputation stays strong. You're not just avoiding bounces—you're earning trust.

When you use an email verification API that validates UTF-8 domain names and mailbox syntax, you’re not just cleaning data—you’re future-proofing your outreach. UTF-8 support is essential for global domains with non-ASCII characters, and syntax checks prevent invalid formats that block delivery. You can verify these cases without guesswork, using the real-time email verification API that handles every edge case reliably.

What’s included in our email verification API — beyond syntax and UTF-8

You get real-time checks that go beyond basic syntax and UTF-8 domain validation. Our API confirms domain existence via DNS and MX records, tests actual mailbox presence using SMTP, and filters out disposable addresses, role-based emails, and known spam traps. This reduces bounces, protects sender reputation, and improves inbox placement. It’s how you turn a raw list into a deliverable one.

Core validation steps built-in

• Checks DNS and MX records for every domain to confirm it exists and is set up to receive email—no guesswork, no false positives.
• Performs real SMTP-level validation only on domains confirmed to be valid, reducing unnecessary server load and improving response accuracy.
• Flags disposable email domains (like mailinator.com or tempmail.org) by cross-referencing with a maintained list of known disposable providers.
• Identifies role-based addresses (e.g. sales@, admin@, info@) that are commonly used for bulk sends and often ignored or bounced—these are high-risk for deliverability.
• Tags known spam trap addresses using a private intelligence feed, which helps you avoid blacklisting and reputation damage.

Why this stack works

SMTP validation isn’t just about checking if someone has a mailbox—it’s about whether that mailbox is open to receiving mail. Some domains pass DNS checks but reject incoming messages due to strict filtering or greylisting. Our API respects those boundaries while still flagging them as risky.

Role-based email addresses aren’t invalid, but they’re often non-responsive and can hurt engagement metrics. Removing them early keeps your list lean and reliable. Use our API to verify your contacts in real time, ensuring your campaigns start strong.

For a full picture, you can test how your emails will land in real inboxes with our deliverability testing tool. See inbox placement results across major providers before you send.

While RFC 5321 outlines SMTP behavior, and industry reports (like those from Return Path) confirm that invalid emails reduce deliverability, the real win comes in automated, accurate filtering at scale. You’re not just checking syntax—you’re building a list that performs.

How to use bulk list verification to clean existing email campaigns

You can clean existing email lists by uploading them via CSV or API, then running a full validation suite that checks syntax, domain reachability, and mailbox existence. This separates valid, invalid, catch-all, and risky addresses so you can remove dead or problematic emails before sending, reducing bounces and improving deliverability.

Start with your list, choose your method

1. Upload your list via CSV file or integrate directly using the email verification API. The API handles real-time validation for apps or automated workflows, while the bulk upload works for one-time cleans of large databases.
2. Run the full validation suite. Each email is checked against RFC standards for syntax, resolved through DNS queries to confirm domain existence, and validated at the mailbox level using SMTP communication protocols. This includes testing for UTF-8 domain names and non-ASCII characters in addresses—critical for global lists.
3. Download a clean, sorted report with addresses categorized by status: valid, invalid, catch-all, or risky. Invalid entries (e.g., typos, malformed syntax) are flagged immediately. Catch-all domains (which accept all emails) are marked for caution—delivery may succeed, but they often lead to spam complaints.

Why it matters: avoid real-world damage

Using unverified lists risks high bounce rates and sender reputation damage. According to RFC 5321, SMTP servers reject messages to non-existent mailboxes, and repeated failures can trigger blacklisting. A clean list means fewer bounces, better inbox placement, and higher engagement.

Don’t overlook risky addresses—like those from disposable domains or corporate role accounts (e.g., admin@, support@). These often result in low engagement or high complaint rates. The report highlights them so you can decide whether to include or exclude them.

After sorting your list, you can re-segment campaigns: send to valid addresses only, and remove catch-alls or risky ones from mass sends. The output can be re-imported into your ESP (Mailchimp, HubSpot, Klaviyo, SendGrid) via the integration hub, ensuring your campaign starts clean.

Real-world impact: Reducing bounce rates and improving deliverability

Using an email verification API that validates UTF-8 domain names and mailbox syntax slashes hard bounces by 60–80% on average. This isn’t just about fewer failed sends—it means cleaner data, better sender reputation with platforms like Mailchimp and SendGrid, and higher inbox placement because you’re only mailing addresses that actually work.

How clean data cuts bounces and protects sender reputation

Every hard bounce sends a signal to inbox providers that your list is unreliable. For senders using third-party platforms like HubSpot or SendGrid, high bounce rates trigger automatic throttling or even account restrictions. By validating UTF-8 domains and proper mailbox syntax upfront, you eliminate these red flags before they can hurt your reputation.

Mailchimp and SendGrid both prioritize sender reputation as a core factor in inbox placement. Clean lists reduce the risk of being flagged as a spam source. You’re not just lowering technical errors—you’re building trust with the very systems that decide whether your message lands in the inbox or the junk folder.

Deliverability starts with reliable data

Invalid or temporary addresses waste sender credits, inflate bounce rates, and skew performance metrics. When you verify at the point of data entry or batch upload—especially with an API that handles internationalized domain names (IDNs) properly—you avoid sending to addresses that don’t exist or are set up for temporary use.

According to RFC 5321, email systems expect valid syntax and reachable domains. Our API checks both, down to the character level, including exotic UTF-8 domain variants like “café.com” or “müller.de”. This level of precision matters, especially for global campaigns. A single malformed domain can cause a message to fail silently.

After cleaning your list with the bulk verification tool, clients routinely report up to 80% fewer hard bounces. That translates directly to improved deliverability. Higher inbox placement isn’t luck—it’s the result of sending only to known, valid, and active inboxes.

Start with 100 free verifications — credits never expire

Begin verifying emails today with 100 free checks—no trial period, no time limit, no risk.

Purchased credits never expire, so your investment in list quality remains valid indefinitely.

Seamless integration with your stack

• Connect directly to Mailchimp, Klaviyo, HubSpot, and SendGrid via native integrations.
• Validate UTF-8 domain names and complex mailbox syntax reliably, both in real time and at scale.
• Use the API to clean lists before campaigns, reduce bounces, and improve sender reputation.

Sources

• The Spamhaus Blocklist averages 30,000–40,000 active listings and its data protects billions of mailboxes globally, with the DNS zone rebuilt every 5 minutes. — Spamhaus (2025)

Keep reading

• Email Verification API & SDKs: the complete developer guide (complete guide)
• Using API-Based Tools to Verify MX Record Consistency Across Global DNS Endpoints
• How to Fix SMTP 451 Temporary Failure with Incorrect Retry Window
• Debugging SMTP 440 Session Timeout in Bulk Email Deliverability
• Email Verification API That Works with SMTP 555 Domains

Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

Can your email verification API handle non-Latin domain names?

Yes. We support full IDN (Internationalized Domain Name) handling, decoding punycode into UTF-8 and validating domains with characters like é, ñ, or あ.

What’s the difference between UTF-8 domain validation and standard domain checks?

Standard checks only work on ASCII domains. UTF-8 support allows proper processing of modern international domains, avoiding false negatives.

Does your API validate email syntax according to RFC 5322?

Yes. We apply full syntax rules from RFC 5322, including quoted strings, special characters, and local-part validation.

How does the API handle catch-all addresses?

We detect catch-all domains but flag them as 'catch-all' — they accept all emails, but the specific mailbox may not exist, posing delivery risk.

Is the email verification API suitable for real-time sign-ups?

Yes. It’s designed for real-time validation during user registration or form submissions to prevent invalid entries at source.

Can I integrate the API with SendGrid or Mailchimp?

Yes. We offer native integrations with Mailchimp, HubSpot, Klaviyo, and SendGrid to automate list cleaning and verification.

What’s the accuracy rate of your email verification API?

98.9% accuracy across bulk and real-time use cases, based on internal testing and consistent results across domains and formats.

Do your credits expire after purchase?

No. All purchased credits are valid forever — no time-limited subscriptions or wasted resources.

How do you detect disposable emails?

We maintain a private, constantly updated list of disposable domains and detect them through pattern matching and DNS behavior.

Can I test the API before buying credits?

Yes. You get 100 free verifications to test the API, integrate with your workflow, and verify results before purchasing.

Does the API check for role-based addresses like info@ or support@?

Yes. We flag common role accounts (e.g. sales@, admin@) as 'risky' due to high unopen rates and low engagement.

Is inbox-placement testing available?

Yes. Our inbox-placement testing simulates delivery to major providers (Gmail, Outlook, Yahoo) to predict real-world inbox placement.