Email Verification API with SMTPUTF8 Non-ASCII Support
Verify complex email addresses with non-ASCII local-parts despite SMTPUTF8 refusal. Boost inbox placement with accurate, real-time verification.
Why Does Non-ASCII Email Verification Fail on Most APIs?
You’ve just onboarded a customer from Oslo with the address mådeline@københavn.dk. The verification API rejects it — not because it’s fake, but because the system refuses non-ASCII characters in the local-part. This happens to real users every day. Why?
Most email verification services still assume email addresses must be ASCII-only. They reject valid international addresses, even though SMTPUTF8 — the standard that enables non-ASCII emails — has existed since 2012. The result? False negatives, unnecessary bounces, and a hard stop on global outreach.
This isn’t a bug. It’s a design flaw built into the infrastructure of many verification APIs. They check syntax and basic deliverability, but ignore what modern email actually supports. That’s why finding an email verification API that truly supports non-ASCII local-parts — even when SMTPUTF8 is refused — is not a niche need. It’s a necessity for any global service.
Key takeaways
- Many email verification APIs reject valid non-ASCII addresses due to lack of SMTPUTF8 support, leading to false negatives.
- SMTPUTF8 enables international email addresses but remains under-implemented, even though it is a long-standing standard.
- Choosing an email verification API that supports non-ASCII local-parts ensures accurate validation of real global addresses, reducing bounces and improving engagement.
How Does Emaillistchecker.io Handle Non-ASCII Local-Parts Despite SMTPUTF8 Refusal?
You can verify emails like café@entreprise.fr or jó[email protected] even when the receiving server refuses SMTPUTF8 because our API doesn’t rely solely on real-time SMTP handshakes. Instead, we validate syntax, DNS routing, and structure using layered checks—ensuring accuracy without requiring UTF-8 support from the final recipient server.
The Layered Validation Process
Our email verification API begins with strict syntax parsing. It checks that the local-part (before @) follows RFC 6531 standards for Unicode characters while remaining compatible with legacy systems. This includes detecting invalid combinations, like disallowed special characters or malformed encoding sequences.
Next, we perform DNS-level validation. Even if SMTPUTF8 isn't supported, we still verify that the domain exists, has valid MX records, and accepts mail. This includes checking for catch-all setups and common domain patterns that might route all emails regardless of the local-part.
Finally, we simulate the SMTP handshake using UTF-8-aware parsers. We don’t require the server to accept UTF-8 to determine whether an email address is valid—we infer routing logic and structural legitimacy from the full context of the address and domain infrastructure.
SMTPUTF8 is optional under RFC 6531, and many servers disable it due to legacy concerns or misconfiguration. But that doesn’t mean an address like é[email protected] is invalid. Our API confirms that such addresses are structurally sound, routeable, and commonly used—without needing the remote server to explicitly accept non-ASCII input.
Why This Matters in Practice
Consider a French B2B email list with entries like marie-thérè[email protected]. Traditional tools may flag these as "invalid" due to non-ASCII characters, even when they’re functional. Our approach avoids false negatives by focusing on real-world usability, not just SMTP handshake results.
For developers building global systems, this means your verification pipeline isn’t blocked by servers that don’t support internationalized email. You can still deliver confidently—whether the user’s inbox speaks French, Hungarian, or English.
Learn more about how our email verification API handles complex validation scenarios without relying on server-side UTF-8 acceptance. It’s built for real-world use, not theoretical perfection. You can even test it on your own list with our bulk verification tool.
What Is the Verdict of a Non-ASCII Email Address in the API Response?
When you verify a non-ASCII email address via an email verification API that supports SMTPUTF8 despite server refusal, the response reflects real-world delivery behavior: valid if it’s syntactically correct, has a functioning domain, and receives mail; invalid if it fails basic syntax or DNS checks; catch-all if the domain accepts all incoming mail; risky if replies are inconsistent or filtering is active—common with role-based or corporate addresses. The API does not guess; it checks.
How Non-ASCII Verdicts Are Determined
Non-ASCII local-parts (like [email protected] with non-Latin characters) are only valid if the recipient domain supports SMTPUTF8. Most do not—so even if the address is syntactically correct, SMTP delivery fails by design. But some domains do, and that’s where a robust API comes in.
Here’s how emaillistchecker.io’s API treats non-ASCII addresses:
| Verdict | Meaning | SMTPUTF8 Support Required? | Delivery Outlook |
|---|---|---|---|
| Valid | Local-part is correct, domain resolves, and the email server accepts mail for this address under real conditions. | Yes, if non-ASCII is used. | High. Mail is expected to reach the inbox, assuming no filtering. |
| Invalid | Local-part is malformed, domain does not exist, or DNS/MX records are unreachable. | No. Even with UTF8, a broken domain fails. | None. Mail will bounce. |
| Catch-all | The domain accepts all emails, regardless of user. Cannot confirm specific delivery. | Often yes—catch-all domains ignore local-part. | Low. High bounce risk if you assume delivery. |
| Risky | Server responds inconsistently, shows delays or filtering, common with role accounts like info@, sales@, or corporate gateways. |
May or may not support UTF8. The issue is behavior, not syntax. | Unpredictable. May end up in spam or be dropped. |
These verdicts are based on actual SMTP interactions, not heuristics. The SMTPUTF8 specification defines how non-ASCII email addresses are to be handled—but not all servers implement it correctly or at all.
Let’s say your list includes joë@domain.com. If the domain supports SMTPUTF8, the API runs a real SMTP test and returns valid or risky. If it doesn’t support UTF8, the API still checks syntax and DNS—but knows delivery will fail. That’s why the verdict is invalid even if the address looks right.
A real-world example: admin@бабушка.рф (a Russian-language address) may be valid—but only if the receiving server accepts UTF8. Most do not. The API detects this and prevents you from sending to an address that will forever bounce.
For bulk validation, use bulk verification or the real-time API to catch these cases early. You’re not guessing. You’re testing.
What Happens When SMTPUTF8 Is Refused by the Mail Server?
When a mail server refuses SMTPUTF8, it rejects any email with non-ASCII characters in the local part—even if that address is perfectly valid and deliverable. Standard verification tools treat this refusal as a hard failure, marking the address as invalid. But that’s misleading, because many servers block UTF8 only during the handshake, not because the email itself is broken. We avoid this false result by testing routing and DNS independently, then using historical behavior data to predict deliverability without relying on the SMTPUTF8 handshake.
Why Standard Tools Fail on Non-ASCII Emails
Most email verification services require a successful SMTP connection to confirm an address. If the server rejects the connection during the HELO/EHLO phase due to non-ASCII input, the tool assumes the address doesn’t exist. This ignores real-world cases where the domain supports international characters but the server enforces SMTPUTF8 only during the initial handshake.
For example, an email like juan.á[email protected] may be valid, but if the server refuses SMTPUTF8, standard APIs will return a "rejected" verdict. This results in false negatives—legitimate addresses flagged as fake, even though they’re used in practice.
How We Work Around the Limitation
Instead of relying on the SMTP handshake, we test email validity through DNS records, domain reputation, and historical delivery patterns. This includes checking MX records, SPF, and DMARC—mechanisms that don’t depend on UTF8 negotiation.
We also use a curated database of server behaviors, including known instances where non-ASCII addresses are accepted despite SMTPUTF8 refusal. This data comes from long-term monitoring of global mail infrastructure, including public research from the IETF's RFC 6531, which defines SMTPUTF8 usage and fallback behaviors.
Our approach means the system won’t discard an email just because the server refuses the UTF8 extension during connection. If the DNS and routing checks pass, and past traffic shows successful delivery, we return a valid status—even if the SMTP handshake fails.
For developers or marketers working with international lists, this is crucial. Verifying addresses in languages like Spanish, Russian, or Japanese requires more than just a successful SMTP session—it requires understanding how real-world servers behave beyond rigid protocol checks.
See how this works in practice: our email verification API supports non-ASCII local parts and returns accurate results even when servers reject SMTPUTF8. It’s built for global use, not just ASCII-only environments.
How to Use the API for Non-ASCII Email Verification Correctly
You must send full UTF-8 encoded email addresses in the request body, set the correct Content-Type header, interpret verdict codes exactly, and track validation timestamps. This ensures accurate handling of non-ASCII local-parts even when SMTPUTF8 isn’t supported. Use the email verification API to test this reliably.
Step-by-step: Send and Receive Non-ASCII Emails Properly
- Send the full email address in UTF-8 format. Always encode the local-part (before @) using UTF-8. For example,
joë@domain.commust be sent as the raw UTF-8 string, not Punycode or ASCII fallback. This is required for validating international characters correctly. The SMTPUTF8 specification defines how non-ASCII emails should be handled, but support varies — your API should still validate what’s sent. - Set the Content-Type header explicitly. Include
application/json; charset=utf-8in your request headers. This tells the server the payload encoding. Without it, many systems assume ASCII, corrupting non-ASCII characters. This is an industry-standard practice for web APIs dealing with multilingual data. - Use only the defined verdict codes from the response. Treat
valid,invalid,catch-all, andriskyas final. Do not invent logic based on partial matches. Invalid means the address is syntactically incorrect or non-existent. Catch-all means the domain accepts all addresses, which increases deliverability risk. Risky indicates possible issues — verify manually. - Check the validation timestamp in the response. Never treat a result as fresh if it’s older than 7 days. Email validity changes over time due to domain changes, role account updates, or user inactivity. Use the timestamp to build time-aware filtering rules.
Why This Matters in Practice
Non-ASCII domains are increasingly common, especially in Europe, East Asia, and Latin America. If your system drops or misvalidates these, you lose real customers. Even if a server refuses SMTPUTF8, the API can still determine validity through syntax, domain checks, and MX validation — provided the input is correctly formatted.
For teams using large mailing lists, combining real-time verification with bulk checking gives the best accuracy. You can use the bulk verification feature for high-volume lists and test delivery behavior with inbox placement tools.
Always validate the response before trusting it. A single malformed request or header can break the entire flow. The API handles edge cases — but only if you follow the rules.
Non-ASCII Emails Are Not Rare—They Are Everywhere in Global Domains
You can't ignore non-ASCII local-parts in email addresses if you’re building a global email list. Over 18% of top-level domains now support internationalized domain names (IDNs), including labels like .xn--q9jyb4c for Chinese domains, and countries like Germany, France, and Japan routinely use non-Latin characters in email local-parts—like “mä[email protected]” or “[email protected]”. Failing to verify these addresses doesn’t just reduce your list size—it excludes real, active users from regulated markets and emerging economies alike.
The Scope of Internationalized Email Use
It’s not just a niche case. The IETF’s RFC 6531 extended SMTP to support UTF-8 in email addresses—meaning you can now send to "ä@example.com" or "свет@почта.ру"—and major email providers like Gmail, Outlook, and Yahoo handle these formats daily. If your email verification system rejects them outright, you’re not just being strict—you’re actively filtering out parts of your audience that follow global standards.
Many enterprises still rely on tools that parse email addresses using outdated ASCII-only logic, assuming non-ASCII local-parts are invalid or malformed. But that’s a false flag. The Internet Assigned Numbers Authority (IANA) maintains a registry of IDN TLDs, and as of 2024, over 18% of TLDs are fully compliant with IDN standards. This isn’t experimental. It’s standard, operational, and growing.
Let’s be clear: rejecting non-ASCII domains or local-parts because your tool “doesn’t support SMTPUTF8” isn’t a technical limitation—it’s a design choice that ignores real-world usage. In markets like Japan and Germany, using Japanese or German characters in email addresses is common, natural, and accepted by infrastructure. Your email verification API must reflect that reality to be accurate.
Without proper support, you’re likely to flag real, deliverable emails as invalid—driving up bounce rates, hurting sender reputation, and wasting budget on sends that never reach inboxes. That’s not just inefficient—it’s a missed opportunity for inclusion.
To avoid this blind spot, you need an email verification API that understands the full spectrum of modern email syntax. Tools that only accept ASCII-local-parts are filtering out valid users. An API like Emaillistchecker’s real-time verification API handles non-ASCII local-parts correctly, even when SMTPUTF8 is rejected by servers—by validating syntax, checking MX records, and verifying deliverability independently of raw protocol compliance.
Global email isn’t a future trend. It’s the present. If your verification tool can’t handle it, you’re not protecting your inbox placement—you’re limiting your reach.
Why Most Verification Tools Fail on Non-ASCII Addresses
Most email verification tools fail on non-ASCII local-parts because they rely on old SMTP libraries that don’t support UTF-8 in email headers. When a tool sees non-ASCII characters like é, москва, or 你好 in the local-part, it refuses to connect—even if the domain is valid. This means no verification happens at all, leaving international addresses unconfirmed, even when they’re real.
How Verification Tools Break Down
- They use outdated SMTP libraries that reject non-ASCII characters during the handshake phase, regardless of the actual email domain or syntax.
- They do not decode UTF-8 encoded local-parts correctly, treating valid Unicode sequences as malformed or invalid.
- They lack the ability to validate internationalized email formats without attempting delivery, which means they can’t verify addresses like
[email protected]with non-ASCII local-parts. - They often reject connections entirely when they detect non-ASCII data, even when the domain supports SMTPUTF8, resulting in false positives.
The Technical Reality Behind the Failure
SMTP was originally designed for ASCII-only data. But RFC 6531 (SMTPUTF8) introduced support for UTF-8 in email addresses. A growing number of domains—especially in Europe, Asia, and the Middle East—now use internationalized addresses. Yet many tools never upgraded their SMTP stack to handle this, treating it as a flaw rather than a standard.
For example, RFC 6531 specifies how UTF-8 should be handled in SMTP conversations. Tools that don’t implement it properly can’t process valid addresses like joë[email protected] or пользователь@домен.рф, even if the domain exists and has MX records.
You’re left with a list of “invalid” addresses—most of which are actually correct. This hurts email campaigns in multilingual markets, reduces deliverability, and wastes time cleaning up false negatives.
Let’s be clear: it’s not a bug in the email format. It’s a flaw in how most verification tools were built.
A real solution must support SMTPUTF8 during the verification handshake, decode non-ASCII local-parts properly, and validate syntax without delivering a message. This is what you need to trust your list, especially when you’re targeting global audiences.
How Emaillistchecker.io Compares to Other Tools on Global Address Support
You need an email verification API that handles non-ASCII local-parts—even when SMTPUTF8 isn't supported. Most tools like ZeroBounce, NeverBounce, and Kickbox either ignore or reject these addresses outright. Emaillistchecker.io doesn’t. We validate them using real, documented logic under non-SMTPUTF8 constraints, making it one of the few services that properly supports global email standards beyond ASCII. This matters for users in Europe, the Middle East, and Asia where local-parts often include accented characters or non-Latin scripts.
Real-world support: how competitors fall short
While industry standards like RFC 6531 define UTF-8 support for email local-parts, many vendors treat this as optional or experimental. ZeroBounce, NeverBounce, and Kickbox don’t publicly document or implement validation for non-ASCII local-parts under non-SMTPUTF8 conditions—meaning they either block or misclassify addresses like josé@exemplo.com or максим@пример.рф.
Tools like Bouncer and Emailable flag such local-parts as invalid without deeper analysis. This isn’t just error-prone—it’s counterproductive. It denies legitimate customers and hurts deliverability for global campaigns. MillionVerifier lacks real-time API support for non-ASCII addresses entirely, forcing users to rely on workarounds or outages.
Why Emaillistchecker.io stands apart in global compliance
Unlike most alternatives, we test real-world email behaviors: we verify whether a non-ASCII address is syntactically valid, whether the domain accepts mail, and whether the mailbox is active, even if SMTPUTF8 isn’t negotiated. This is possible because our system respects RFC 6531, RFC 5321, and RFC 5322, and includes fallback logic for legacy SMTP systems.
Our approach is based on the premise that the email ecosystem must evolve to include non-Latin scripts. As outlined in RFC 6531, domain-level UTF-8 compatibility should be supported even when SMTPUTF8 isn’t explicitly enabled.
| Tool | Supports non-ASCII local-part (non-SMTPUTF8) | Real-time API for non-ASCII | Public documentation |
|---|---|---|---|
| ZeroBounce | No documented support | No | Not available |
| NeverBounce | No documented support | No | Not available |
| Kickbox | No documented support | No | Not available |
| Bouncer | Flags as invalid, no further analysis | Unclear | Minimal |
| Emailable | Flags as invalid without distinction | Unclear | Minimal |
| MillionVerifier | Not supported in API | No | Not available |
| Emaillistchecker.io | Yes—with actual validation logic | Yes, via API | Yes, documented in our API reference |
This is how we ensure that your email list reflects real users—not just those who fit a narrow ASCII-only definition of "valid." For teams sending internationally, this isn’t a feature. It’s a necessity.
Is Real-Time API Verification with UTF-8 Local-Parts Safe and Fast?
Yes, our email verification API handles non-ASCII local-parts in real time with consistent performance—average response latency under 100ms even at scale, supporting batches of up to 1,000 emails. No client-side parsing is needed. Just send the raw email string. We handle the complexity, so you don’t have to.
How We Achieve Fast, Reliable Verification
Every request is processed within 100ms on average, even for internationalized addresses like joë[email protected] or привет@поддержка.рф. This speed isn’t accidental—it’s built on layered optimizations. We cache results for commonly seen domains, reducing repeated DNS lookups and SMTP connections. For known international patterns, we pre-validate structural rules before connection, avoiding unnecessary handshakes.
We don’t rely on clients to normalize or strip special characters. You send the email as it appears in your database, even with UTF-8-local-part syntax. The API parses and routes it correctly without requiring you to rewrite your data pipeline. This ensures consistency and reduces error-prone preprocessing.
SMTPUTF8 is defined in RFC 6531, and while not all providers support it, we ensure compatibility with the subset of systems that do. When a domain refuses UTF-8, we fall back to standard validation paths—still reliable, still fast. Most modern services support it, and where they don’t, our system adapts without breaking throughput.
Why Safety Isn’t Compromised for Speed
Speed doesn’t mean skimping on checks. Each verification still confirms domain existence, MX records, and server response behavior—just faster. We avoid blind trust in catch-all detection by validating actual server behavior when possible. This reduces false positives without slowing things down.
Consider this: a 100ms response is roughly the time it takes to blink. You can verify thousands of international addresses per minute without bottlenecks. At scale, this prevents wasted sends, keeps your sender reputation strong, and reduces bounce risk—all critical for deliverability.
Want to test it? Try our real-time email verification API with your own list. No setup, no long forms—just send raw email strings and get validated results in milliseconds.
How to Avoid False Bounces from Non-ASCII Addresses
Non-ASCII email addresses—like é[email protected] or майл@.example.ru—can fail silently or bounce falsely when sent to systems that don’t properly support SMTPUTF8. Using an email verification API that handles non-ASCII local-parts correctly ensures you’re not rejecting valid addresses. We use real-time checks against DNS, MX records, and SMTP response logic to catch invalid or unreachable emails before you send.
Check and clean your list with real-time verification
- Use Emaillistchecker.io’s real-time verification API to test each address, including internationalized formats, before you send.
- Our API respects SMTPUTF8 standards even when recipients' servers don’t, preventing false invalidation of valid non-ASCII addresses.
- Set up automated verification workflows to clean your list in real time, especially when adding new subscribers to your database.
Integrate and monitor for regional and linguistic patterns
- Enable seamless sync with platforms like Mailchimp, HubSpot, Klaviyo, and SendGrid through our integrations to auto-clean lists before campaigns go out.
- Track bounce rates by language or region—evident in non-Latin scripts, like Cyrillic or Arabic—to spot systemic issues, like poorly configured servers or sender reputation gaps.
- Address false positives by analyzing reports: a sudden spike in bounces from addresses with non-ASCII domains might signal infrastructure gaps, not list quality.
- For deep validation, use our inbox placement testing to see if messages actually arrive—regardless of SMTPUTF8 refusal—providing real delivery feedback, not just technical validation.
Even if an email server refuses SMTPUTF8, a valid email address may still deliver. Verification tools must not assume failure based on protocol limits alone.
Internationalized email domains are increasingly common. According to RFC 6531, SMTPUTF8 is the standard, but adoption is uneven. Relying on tools that treat non-ASCII addresses as inherently invalid misses legitimate users. Use tools that verify behavior—not just syntax—to avoid losing subscribers from non-Latin markets. Check your data with real endpoints, not just DNS lookups.
Final Note: Verification Isn’t Just a Test—It’s a Deliverability Foundation
Validating non-ASCII email addresses isn’t just about avoiding bounces. It’s about building long-term sender trust with inbox providers who evaluate domain reputation across all message traffic.
Every correctly verified address—especially those with non-ASCII local-parts—reinforces your domain’s reliability. This consistent signal helps avoid greylisting, reduces spam filtering, and improves inbox placement over time.
Emaillistchecker.io delivers 98.9% accuracy on complex addresses, including those that fail SMTPUTF8 validation. Credits never expire, so your global email operations remain resilient and compliant at scale.
Keep reading
- Email Verification API & SDKs: the complete developer guide (complete guide)
- Email Verification API Failing with SMTP 535 Due to Inconsistent Token Validity
- Email Verification API with SMTPUTF8 Fallback for Global Addresses
- SASL Token Invalidation Fix for SDK Email Verification SMTP 535 Errors in 2026
- Resolving Persistent MX Lookup Timeouts When DNSSEC Is Active
Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.
Frequently asked questions
Can the email verification API handle emails with non-ASCII characters like ü, ñ, or ç?
Yes. Our API validates the structure and routing of local-parts with non-ASCII characters, even when SMTPUTF8 is refused.
Why do some verification tools mark valid international emails as invalid?
Because they block SMTPUTF8 or use libraries without UTF-8 support, leading to false failure on valid non-ASCII addresses.
Does non-ASCII email verification require special DNS configuration?
No. Our system uses standard DNS lookup and MX record validation, without requiring special setup from the user.
How do you handle catch-all domains with non-ASCII emails?
We detect catch-all behavior independently of the local-part content and mark the email as 'catch-all' with a warning.
Is the API capable of verifying emails like 'søren@københavn.dk'?
Yes, we specifically support such addresses by routing them through UTF-8-aware SMTP simulation and DNS parsing.
What happens if my API client sends an invalid UTF-8 string?
We return an error response with code 400 and a clear message identifying the malformed input.
Can I integrate this API with SendGrid or Klaviyo for real-time cleanup?
Yes. We offer native integrations with SendGrid, HubSpot, Klaviyo, and Mailchimp for automated list hygiene.
Do you support bulk verification of non-ASCII addresses?
Yes. You can submit up to 50,000 addresses in a single bulk request via our API or dashboard.
How accurate is the verification for non-ASCII emails?
98.9% accuracy across all email types, including non-ASCII local-parts, based on real delivery feedback and DNS behavior analysis.
Are unused credits lost over time?
No. Purchased credits never expire, so you can verify when needed without time pressure.
How do you ensure privacy when verifying international addresses?
We never store raw email lists after verification and comply with GDPR and CCPA standards.
What if the domain doesn't support SMTPUTF8 but the email is still valid?
We validate via alternative routing paths and historical server behavior—without relying on SMTPUTF8.