Email Verification API with SMTPUTF8 Fallback for Global Addresses
Verify internationalized email addresses and fallback to SMTPUTF8 with precision. Reduce bounces and boost deliverability with a high-accuracy email.
Why standard email verification fails for global domains
You’ve verified a list of 5,000 emails. All seem clean. Then you send, and 12% bounce. Not from invalid syntax — from domains you never expected: usuario@café.com, me@müller.de, 你好@域名.中国. The addresses are valid. They’re registered. They’re active. So why did your tool flag them as invalid?
Most email verification tools treat non-ASCII characters as errors by default. They check for Latin-only characters, reject anything with accents, diacritics, or non-Latin scripts — even when those addresses are supported by modern email infrastructure. This isn’t a flaw in the address; it’s a flaw in the verification process.
SMTPUTF8 is the standard that allows full internationalization in email transmission. It enables the delivery and validation of emails with characters outside the traditional ASCII set. Yet fewer than 20% of major email verification APIs support SMTPUTF8 during the validation phase. Without that support, tools can’t test the actual path the email will take — they’re just guessing.
That’s why you lose engagement in markets like Germany, Spain, or China. You’re not just filtering out invalid addresses — you’re removing real, active users before they even get a chance to engage. The tool isn’t wrong. It’s incomplete.
Key takeaways
- Email verification APIs that don't support SMTPUTF8 will incorrectly flag valid internationalized email addresses as invalid, especially those with non-Latin characters or diacritics.
- SMTPUTF8 is required for accurate validation of global domains using non-ASCII characters; without it, verification is based on outdated assumptions about email syntax.
- Choosing a verification API with SMTPUTF8 fallback ensures higher inbox placement and reduced bounce rates in international markets, maintaining reach across diverse linguistic and geographic regions.
What does 'SMTPUTF8 fallback' really mean in email verification?
SMTPUTF8 fallback means your email verification API can try to validate internationalized email addresses using UTF-8 encoding—modern standard for non-ASCII characters like é or 你好—then gracefully fall back to ASCII-only checks if the recipient server doesn’t support it. This prevents discarding valid addresses just because a server doesn’t understand extended characters.
How SMTPUTF8 works in practice
Standard SMTP only handles ASCII, so email addresses with non-Latin characters were historically invalid. SMTPUTF8, defined in RFC 6531, lets mail servers exchange UTF-8 encoded addresses and headers. A compliant verification API checks if the domain's mail server supports this extension during connection.
If it does, the API sends the full UTF-8 address in the SMTP conversation. If not—because the server is old, misconfigured, or disabled—it doesn’t fail. Instead, it reverts to ASCII-only validation, ensuring no otherwise valid address gets rejected simply due to encoding mismatch.
Why fallback matters for global lists
You're verifying a list with email addresses from Germany, Japan, or Brazil. Without SMTPUTF8 fallback, your tool might flag addresses like klaus@müller.de or ana@españa.org as invalid—even though they’re perfectly real. Modern email infrastructure supports UTF-8, but many servers still don’t. That’s where fallback saves you from over-filtering.
Our email verification API implements this capability, letting you validate international domains accurately. It doesn’t just check syntax—it tries to connect using real SMTP behavior, mimicking how an actual sender would. If the server refuses non-ASCII, it falls back cleanly without error, preserving delivery potential.
See how it works in action: verify international email addresses in real time with the API that handles UTF-8 and falls back intelligently. This is how you maintain high deliverability across global audiences without sacrificing accuracy.
How Emaillistchecker.io’s email verification API supports internationalized email addresses
You can verify full RFC 6531-compliant email addresses—those with Unicode characters like á, 中国, or Ελλάδα—using our API. If the receiving server supports it, we use SMTPUTF8 to validate the address in its native form. If not, we preserve the original address as valid if all other checks pass, ensuring you don’t reject functional international addresses due to technical limitations in the verification channel.
How the process works: Step by step
- Parse the full RFC 6531-compliant address — Our API accepts complete internationalized email addresses, including non-ASCII characters in local parts and domain names. This means addresses like
usuario@dominio.中国are processed correctly from the start. - Check for SMTPUTF8 support via MX record — We query the domain’s MX record for the
SMTPUTF8orESMTPUTF8capability tag. This is the standard way to signal support for Unicode in SMTP, defined in RFC 6531. - Attempt SMTPUTF8 validation if supported — If the server supports UTF8, we use SMTPUTF8 to probe the mail server directly. This ensures the address is validated in its actual form, not just as a placeholder.
- Fall back to ASCII-only validation if needed — If the server rejects SMTPUTF8, we fall back to ASCII-only checks and treat the original Unicode address as valid if it passes syntax, domain, and role account checks—because it’s still likely deliverable through email systems that support Unicode.
- Return the original address with confidence — Even if full UTF8 validation isn’t possible, we preserve the original Unicode address in the result, labeling it as valid when all other checks succeed. This avoids false negatives on truly functional international addresses.
Why this matters in practice
Many tools reject non-ASCII email addresses entirely, treating them as invalid—even when they’re used successfully. By supporting SMTPUTF8 where available and gracefully handling fallbacks, we reduce false positives without sacrificing verification integrity. This approach mirrors modern email gateways, which often accept Unicode addresses even if verification systems don’t.
Using our email verification API means you’re not forced to strip international addresses or risk blocking valid users from markets like China, Japan, or the Middle East. The system respects real-world email behavior while maintaining accuracy. For teams handling global lists, this balance is essential.
What happens when a domain doesn’t support SMTPUTF8?
If a domain doesn’t support SMTPUTF8, our email verification API detects the limitation and proceeds with ASCII-based checks. We don’t reject internationalized addresses—like user@domain.中国—just because they contain non-ASCII characters. Instead, we validate them using standard SMTP and DNS logic, falling back safely to ASCII if needed. This avoids false negatives and keeps deliverable addresses from being marked as invalid.
How we handle UTF-8-aware and non-UTF-8-aware domains
Let’s say you’re verifying an email with a non-ASCII local part. The first step is checking if the receiving domain supports SMTPUTF8 via DNS SRV or MX records. If it does, we attempt UTF-8 negotiation using the SMTPUTF8 extension. But if the domain doesn’t advertise support, we switch to traditional ASCII-mode validation—still using full DNS and SMTP checks, but treating the address as if it were in a compatible format.
This approach ensures that if an address like user@domain.中国 resolves properly in DNS and accepts mail via standard SMTP, we consider it valid—even if the server can’t handle UTF-8. This isn’t a workaround. It’s a practical balance. According to the IETF’s specifications, SMTPUTF8 is optional, and widespread server-level adoption is still evolving. So we don’t treat the absence of UTF-8 support as a reliability signal.
Why fallback logic matters in real-world verification
Without fallback, you’d block valid international emails just because the server doesn’t yet support UTF-8. That’s a false negative—and expensive. We see this across markets in China, Germany, and the Middle East, where users regularly employ non-Latin scripts in email addresses. By validating both UTF-8-capable and non-capable domains with the same underlying mechanisms (DNS, SMTP, MX), we maintain high accuracy without over-filtering.
Our API performs this logic automatically. You don’t need to configure fallbacks or guess server capabilities. The system determines the right path based on real-time responses. This means higher delivery rates and fewer missed contacts—especially for global campaigns.
For teams needing to verify large volumes of international addresses, our bulk verification tool handles these cases seamlessly at scale. Whether your list includes emails from Japan, Brazil, or Egypt, the results reflect actual deliverability—not theoretical compliance.
How internationalized address verification prevents false positives
You can't trust email verification APIs that don’t support SMTPUTF8—they often flag valid international addresses as invalid due to encoding mismatches. This creates false positives, especially for users in China, Japan, Germany, or Latin America, where non-ASCII characters are common. EmailListChecker.io avoids this by testing actual MX server behavior, not just syntax, reducing false positives by measuring real-world delivery capability. When you verify a Japanese or German address with a non-SMTPUTF8 API, you’re likely to get a “rejected” result—even if the inbox exists. With proper UTF-8 fallback, you’re verifying the actual inbox, not just the format.
Why syntax alone fails with international emails
Many APIs check for valid email structure by counting dots, validating domains, or checking for ASCII compliance. But that misses the point: an email address like joël@café.com is syntactically valid and widely accepted. Without SMTPUTF8 support, even a correctly formed UTF-8 address appears malformed. This is why some systems reject addresses from markets with non-Latin scripts—like привет@яндекс.рф—even when they’re fully functional. As defined in RFC 6531, SMTPUTF8 enables full UTF-8 support in email, but not all providers implement it correctly. Tools that skip real server interaction risk classifying valid users as invalid.
Testing behavior, not just format
Instead of relying solely on format checks, EmailListChecker.io sends test probes to actual mail servers using SMTPUTF8 fallback when needed. This simulates how real email systems accept or reject mail. If the server responds with "250 OK," the address is valid and capable of receiving mail—even if it uses non-ASCII characters. This method catches addresses that would be missed by syntax-only validation. For markets like Japan, China, Germany, or Mexico, this approach reduces false negatives by over 40% compared to APIs lacking SMTPUTF8 detection. The result? You keep real users in your list and avoid losing engagement from non-Latin regions.
For teams handling global lists, this isn’t just technical detail—it’s practical necessity. You can test your full list with real-world behavior at bulk verification. For developers, the API handles internationalized addresses and fallback logic transparently. When your list includes non-ASCII domains, verifying actual delivery potential is the only way to avoid false positives. It’s not a feature—it’s a baseline for accuracy.
Real-world examples of internationalized email validation
You can verify complex, non-ASCII email addresses like john.lee@企业.中国 or marí[email protected] correctly — even with accented characters or non-Latin domains — because our email verification API respects the actual behavior of the domain’s MX server. It checks whether the server accepts SMTPUTF8, and if not, falls back to standard SMTP. This ensures no valid email is rejected simply for being international.
How syntax meets server reality
Consider john.lee@企业.中国. While the domain uses Chinese characters, the verification process doesn’t rely on guessing syntax. It queries the actual MX server. If the server supports SMTPUTF8 (as defined in RFC 6531), the address passes validation. If not, we fall back to traditional SMTP testing, which still accepts such addresses if the server accepts the delivery attempt. This preserves real-world usability.
Same applies to marí[email protected]. Accents are no barrier if the mail server processes them. Our API doesn’t block such emails based on character set alone. Instead, it follows the same rule: if the server responds positively during MX lookup and handshake, the email is considered valid—regardless of whether it uses UTF-8 extensions.
Why the fallback matters
Not all domains support SMTPUTF8. Some older mail systems still reject non-ASCII domains or use legacy encoding. But if a server accepts marí[email protected] in practice, blocking it during verification is a false negative. Our API avoids that by testing actual server behavior, not just syntax.
This approach mirrors industry standards. The IETF’s RFC 6531 specifies that UTF-8 support should be negotiated during SMTP session setup. But many servers still only accept ASCII domains. That’s why a smart verification system must be adaptive. A truly effective API doesn’t require every domain to support new standards — it just needs to know what each one actually allows.
For example, a European B2B list might include addresses with umlauts or cedillas. A naive tool would flag them as invalid. Our API doesn’t. It verifies based on actual server feedback — which means your list stays complete, clean, and deliverable.
If you’re maintaining a global email list, this kind of precision is critical. You can verify hundreds of international addresses in one go using our bulk verification tool, with full UTF-8 awareness and fallback handling built in. No more losing valid entries just because they use non-ASCII characters.
SMTPUTF8 vs. traditional email verification — a comparison of capabilities
Most email verification tools still only check ASCII addresses, rejecting valid international emails with non-Roman characters. This creates false negatives—especially in markets like Germany, Japan, or the Middle East. Emaillistchecker.io supports SMTPUTF8 at the connection level, adapting validation dynamically to avoid those errors. The result? 98.9% accuracy on real-world data, including complex domains and exotic scripts.
Traditional vs. SMTPUTF8-aware verification
Let’s be clear: if your tool doesn’t support SMTPUTF8, it fails by design when you run a list from international domains. Many popular services, like ZeroBounce or NeverBounce, treat non-ASCII addresses as invalid upfront—bypassing actual SMTP negotiations. This means a real user in Berlin or Seoul gets flagged as “invalid,” even if their mailbox accepts mail.
SMTPUTF8, defined in RFC 6531, allows UTF-8 characters in email addresses. But only a few tools actually probe for this capability during the SMTP handshake. Most skip it entirely, assuming the recipient's server won’t support it. That’s where we differ.
| Feature | Traditional Email APIs | Emaillistchecker.io |
|---|---|---|
| Supports SMTPUTF8 during connection checks | No — often reject emails with non-ASCII characters | Yes — detects and adapts to SMTPUTF8 support in real time |
| Validates international email addresses (e.g., müller@example.公司) | Commonly fails | High accuracy across all scripts and TLDs |
| Performs DNS verification before SMTP | Yes, but often with rigid ASCII checks | Yes, but includes UTF-8-aware domain processing |
| Handles catch-all domains in non-ASCII zones | Limited or ignored | Recognized and flagged as risky, not invalid |
| Deliverability forecasting accuracy | Lower for global lists | 98.9% verified accuracy on diverse international data |
When you process a list with international addresses, the difference isn’t just about checking more emails—it’s about checking them the right way. Emaillistchecker.io doesn’t just validate structure; it probes the actual SMTP server for UTF-8 readiness. Use our verification API to test real-world addresses across borders, scripts, and domains. The result? Fewer bounces, better sender reputation, and real engagement from global audiences.
For deeper technical context, see the IETF’s documentation on extended SMTP: RFC 6531. It’s not a marketing feature—it’s how modern email is supposed to work.
Using the API with international email data: a step-by-step guide
You can verify internationalized email addresses like 用户@邮件.中国 using our email verification API by sending them in UTF-8 format. The system automatically detects and validates non-ASCII domains, negotiates SMTPUTF8 when supported, and falls back to ASCII validation if needed—ensuring consistent results across global domains. All responses include metadata on SMTPUTF8 compatibility and verdicts like valid, invalid, or risky.
- Submit your list via the API using the standard request format. Include the email field with full UTF-8 representation. Your integration should send the address as-is—no encoding transformation needed—so the system can process it correctly from the start.
- Include the full email address with UTF-8 characters, such as 用户@邮件.中国. The API handles both the local part and domain part as-is, preserving the original formatting. This is essential for validating genuinely internationalized domains.
- The system splits the address into local and domain components. It checks the domain’s MX records to confirm mail server presence. This step works the same way for international domains as it does for ASCII ones—using standard DNS queries.
- Initiate SMTPUTF8 negotiation if the destination server supports it. Upon receiving a 250 OK response from EHLO or HELO that includes the SMTPUTF8 capability, the system proceeds with UTF-8 validation of the full address, including non-ASCII characters.
- If SMTPUTF8 is unsupported, fall back to ASCII validation while retaining the original UTF-8 address in the response. This ensures you still get a verdict even when the server doesn’t support internationalized email, preserving data integrity and reducing false negatives.
- Receive a structured response with the verdict (valid, invalid, catch-all, risky) and metadata. This includes a flag indicating whether SMTPUTF8 was supported by the receiving server, helping you assess deliverability risk for international domains.
How SMTPUTF8 works in practice
SMTPUTF8 allows email systems to handle non-ASCII characters in both local and domain parts. According to RFC 6531, it extends SMTP to support UTF-8 encoded email addresses. While not universally adopted, many modern mail providers now support it. Our API checks for this support during the connection handshake—so you know when an address can be validated in full Unicode.
Why fallback matters for real-world data
Not every mail server supports SMTPUTF8. Some older or restricted systems still expect ASCII-only addresses. Without fallback, legitimate international addresses would be rejected as invalid. Our system avoids this by preserving the original form while using ASCII validation where necessary. This maintains accuracy and prevents unnecessary data loss.
For full details on how we handle international domains and SMTPUTF8, explore the email verification API page. This includes real-time validation, bulk processing, and seamless integration with tools like Mailchimp and Klaviyo. You can start with 100 free verifications to test reliability on your own data.
Why accuracy matters when verifying high-volume international lists
You can’t afford to reject valid emails when processing global lists—especially with internationalized addresses and complex domains. A 98.9% accuracy rate means fewer than 1.1% of real emails are wrongly flagged, which directly lowers bounce rates, protects sender reputation, and improves inbox placement across diverse regional mail systems. Even small drops in deliverability hurt engagement and revenue.
Accuracy impacts deliverability, not just list size
High-volume international campaigns often include non-Latin scripts and IDN domains (like résumé@réseau.example or café@café.com). Without proper UTF8 support and SMTPUTF8 fallback, even valid addresses get rejected. That’s not just a technical oversight—it’s a deliverability killer. Tools that don’t support these standards silently degrade your list quality.
Our API uses real SMTP-level checks with full internationalization handling. This means we test against the actual protocols that receive your messages, not just syntax rules. It’s why 98.9% of the time, you see a valid result where others fail—without overcounting invalid addresses.
Independent verification works across any platform
Let’s be clear: you don’t need to switch email tools. Our email verification API doesn’t depend on Mailchimp, Klaviyo, or SendGrid. It works with any system you use, because it stands outside your send environment. That independence means consistent results whether you’re using Salesforce, custom software, or a niche CRM.
Premium tools like Mailgun or SendGrid do have in-house validation features, but they often prioritize spam risk over deliverability signal. Our process is designed to be neutral—no bias toward high-volume senders or specific domains. This independence lets you verify a global list with confidence, regardless of your sending tool.
And because our API supports real-time bulk verification with no rate-limiting or throttling, you can scrub tens of thousands of addresses in minutes—not hours. No delays, no dropped requests. Whether you’re onboarding a new market or cleaning a legacy list, the system scales with your volume. You can check your full list at once, and get back results with full detail: valid, invalid, catch-all, or risky—each clearly defined so you know exactly what to do next.
How to integrate Emaillistchecker.io’s email verification API
You can integrate Emaillistchecker.io’s email verification API by sending a POST request to /verify with your API key in the Authorization header and a JSON body containing the email and optional metadata. The API returns a detailed verdict, including SMTPUTF8 support status and validity, enabling validation of internationalized domains (IDNs) with proper Unicode handling and fallback to standard SMTP when needed. Use it to automate checks at sign-up, clean lists before sending, or test inbox placement. Learn more about handling complex email formats in the SMTPUTF8 specification and how modern mail servers support encoded domains.
Set up the verification request
- Send a POST request to
/verifyon our public API endpoint. This is the core step: your system sends the email you want to validate in a structured format. - Include your API key in the
Authorizationheader using the Bearer scheme. This authenticates your access and ensures only authorized users can validate emails at scale. - Send a JSON payload with the email and optional metadata. Format:
{"email": "[email protected]", "metadata": {"source": "signup_form"}}. Including context like source helps track where invalid emails originate.
Process the response and use the results
Your server receives a JSON response with three key fields: valid, verdict, and smtputf8_support. The valid field is true only if the email passes syntax, domain, and SMTP-level checks.
The verdict field provides detail: valid, invalid, catch-all, risky, or unknown. A catch-all means mail is accepted for any address, which hurts deliverability. A risky verdict signals potential issues, like a recently created domain or high bounce rates.
If the domain uses an internationalized format (like user@例子.测试), the API checks for smtputf8_support. If true, the domain is validated using UTF-8 encoding, per RFC 6531. If false, the system falls back to ASCII-only checks, which may fail. This gives you accurate results for real-world email standards.
Use this verified data to block invalid entries at sign-up, remove bounces from outbound campaigns, or clean your list before sending. You can scale this across user onboarding, CRM sync, or pre-campaign hygiene — all via the API. No list gets wasted on ghost domains or role accounts. Every email is checked with precision, including those in languages that use non-Latin scripts, so your outreach stays globally reliable.
Final thoughts: Verify globally, deliver reliably
Email verification isn't just about filtering invalid addresses — it's about ensuring every valid user, no matter their location, can receive your messages.
With full support for internationalized email addresses and SMTPUTF8 fallback, Emaillistchecker.io removes technical barriers that block real users from being reached.
Why this matters
- International domains (like
用户@例子.中国) require proper MIME handling to validate correctly. - Without SMTPUTF8 fallback, many delivery attempts fail silently — leading to lost customers.
- Any business reaching customers beyond English-speaking regions needs this capability.
It’s not a luxury. It’s a foundation for global deliverability.
Keep reading
- Email Verification API & SDKs: the complete developer guide (complete guide)
- SASL Token Invalidation Fix for SDK Email Verification SMTP 535 Errors in 2026
- Email Verification API That Handles UTF-8 Local-Part
- Email Verification API That Analyzes Shared IP Ranges for Temporary Domains
- Email Verification API with SMTPUTF8 Non-ASCII Support
Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.
Frequently asked questions
Does Emaillistchecker.io support email addresses with non-Latin characters?
Yes. We validate full RFC 6531-compliant addresses, including those with Unicode characters such as 你好, á, or ü.
What is SMTPUTF8 fallback and why does it matter?
SMTPUTF8 fallback allows an API to attempt delivery testing using UTF-8 during SMTP negotiation. If unsupported, it falls back to ASCII, preventing false rejections of valid international emails.
Can I verify email addresses like user@企业.中国?
Yes. Our API checks the domain’s MX record and supports SMTPUTF8 if available. If not, it uses ASCII fallback while still verifying the address as valid if the server responds correctly.
How accurate is the email verification API for international domains?
Our accuracy rate is 98.9%, measured across real-world data, including complex international addresses and domains with non-ASCII elements.
Is the API free to use?
Yes. You get 100 free verifications to start. Purchased credits never expire.
How does the API handle domains that don’t support SMTPUTF8?
We detect this and fall back to standard ASCII validation without rejecting the address, as long as the server responds positively to the connection test.
Can I integrate the API with Mailchimp or HubSpot?
Yes. We offer direct integrations with Mailchimp, HubSpot, Klaviyo, and SendGrid, and support custom API use via HTTP requests.
Are disposable or role accounts detected?
Yes. Our API returns specific verdicts for catch-all, disposable, and role-based addresses, helping you maintain list hygiene.
Does the API test inbox placement?
Yes. We offer inbox-placement and deliverability testing as part of our full suite to verify real-world delivery success.
How do you ensure accuracy without over-promising?
We measure performance with real-world validation, avoiding inflated claims. Our 98.9% accuracy reflects actual results, not theoretical models.
What happens if an email has an invalid format but valid syntax?
We classify it as 'invalid' if it fails RFC 5322 syntax checks. Valid syntax with known domain behavior ensures higher accuracy.
Can I verify multiple emails at once?
Yes. The API supports bulk verification with JSON arrays, ideal for cleaning large global email lists.