Article
Can an Email Verifier Check International Domains? Yes, If It Converts IDNs First
By Unlimited Verifier Team ·

Summary
A capable email verifier can check addresses on international domains, but only if it converts the domain to punycode (xn-- form) before running DNS, MX and SMTP lookups. Non-ASCII characters before the @ are the harder case and depend on the receiving server supporting SMTPUTF8.Yes, a capable email verifier can check addresses on international domains, provided it converts the domain to its ASCII form (punycode) before running DNS, MX and SMTP lookups. The real gaps are internationalized email addresses with non-ASCII characters before the @, which depend on the receiving mail server supporting SMTPUTF8.
Quick answer
- Internationalized domains (IDNs) work when the verifier converts them to
xn--punycode before lookup. Many false "Invalid" results on these domains trace back to skipped or mismatched conversion, not missing mailboxes. - Non-ASCII local parts (the text before the @) are harder. They need SMTPUTF8 support on the receiving server, and that support is not universal.
- Check the conversion rule. Libraries disagree on characters such as
ß. A wrong rule can send the lookup to a different, real domain and return a false Valid. - Test before you trust. Run a 25–30 address control set with known outcomes before cleaning a full international list.
- Unlimited Verifier includes unlimited standard verification on every plan, so control tests are cheap to repeat. Its published feature list doesn't mention IDN or SMTPUTF8 handling, so confirm that behaviour yourself.
What is an international domain, and why does it change the lookup?
An internationalized domain name (IDN) contains characters outside basic ASCII, such as münchen.de, or labels written in Cyrillic, Arabic or Chinese script. DNS was built around ASCII, so each IDN is converted to punycode, with every converted label prefixed xn--. For example, münchen.de becomes xn--mnchen-3ya.de. The encoding is defined in RFC 3492. The top level can be internationalized too. The IANA root zone database lists non-Latin top-level domains, and .рф appears there in its xn--p1ai form.
A verifier that sends raw Unicode to DNS gets no answer and reports the domain as nonexistent. That output looks identical to a genuinely dead domain unless the tool logs the conversion step. This is why the failure is easy to miss.
Bottom line: An IDN can only be checked after it has been converted to ASCII, so conversion is the first thing to verify in any tool.
Can an email verifier check an address on an international domain, layer by layer?
Yes, as long as each layer works on the converted name. A verifier runs its checks in sequence, and a failure at one layer usually stops the rest.
| Check | What should happen with an IDN | Common failure |
|---|---|---|
| Syntax | Unicode letters are accepted in the domain once normalized | Valid Unicode rejected as "invalid syntax" |
| Domain / DNS | Domain is converted to xn-- form, then queried |
Raw Unicode is queried, so a live domain looks nonexistent |
| MX | MX lookup runs on the converted name. If no MX record exists, the RFC 5321 implicit MX rule falls back to the A record | Fallback skipped, so a reachable domain looks undeliverable |
| SMTP mailbox | Verifier asks the server whether the recipient exists (RCPT TO) |
Server rejects the probe, or blocks or rate-limits the verifier |
| Catch-all | Domain accepts every address, so the mailbox can't be confirmed | Looks Valid even when the mailbox doesn't exist |
Syntax and DNS are usually reliable once conversion works. The SMTP layer is where ambiguity usually appears. Strict servers and corporate gateways can reject or stall a probe even when the mailbox exists, so a verifier can't always confirm it. Ask any vendor how it handles each layer for IDNs, not just whether it "supports" international addresses.
Bottom line: The weakest layer sets how far you can trust a result, and for international lists that is usually SMTP.
What's the difference between an IDN domain and an international email address?
People use "international email" to mean two different things, and treating them as one leads to bad cleaning decisions.
| Type | Example | Non-ASCII part | What it needs | Typical failure if mishandled |
|---|---|---|---|---|
| IDN domain | anna@münchen.de |
Domain only | Punycode conversion before DNS | False Invalid from a failed lookup |
| Internationalized local part (EAI) | jürgen@example.de |
Before the @ | SMTPUTF8 on the sending client and the receiving server, per RFC 6531 | Rejection that looks like a missing mailbox |
| Both | jürgen@münchen.de |
Both parts | Conversion and SMTPUTF8 | Either failure above |
For EAI addresses, the sending client declares SMTPUTF8 on MAIL FROM, and the receiving server must advertise support for it. Because support isn't universal, a real UTF-8 mailbox can return a rejection that reads like "no such user."
Two practical rules follow:
- Don't auto-delete EAI "Invalid" results. Split them into their own file and review them, because the rejection may reflect the server's limits rather than the mailbox.
- Read the reply text. Rejections that mention character set, encoding or address form point to a protocol issue, not a dead address.
Where you control the signup form, real-time email validation stops bad addresses from entering the list in the first place.
Bottom line: IDN domains are a conversion problem and EAI addresses are a server-capability problem. Handle them in separate buckets.
How should a verifier convert international domains?
It should use the current IDNA mapping rules, and the version matters. The original standard, IDNA2003, maps certain characters before conversion. IDNA2008, defined in RFC 5890 through 5893, treats them differently. Unicode UTS #46 defines the mapping rules that modern implementations generally follow, including a transitional mode that bridges the two.
Here is the trap. Under IDNA2003's transitional mapping, straße.de becomes strasse.de. Under IDNA2008, the ß is kept and the domain becomes xn--strae-oqa.de. A verifier on the wrong rule can query a domain that exists but isn't the one the address belongs to. That produces a false Valid, which is worse than a false Invalid because nothing looks wrong.
Libraries differ too. Python's built-in codec implements the older IDNA2003 rules, while the third-party idna package defaults to IDNA2008. A cleaning script that doesn't record which one it used can convert the same domain two different ways.
Normalization is the second issue. One visible character can be stored as a single code point or as a base letter plus a combining accent. The bytes differ, so the lookup differs. Normalize input to a consistent form, usually NFC, before conversion.
When you evaluate a tool, ask three things: which IDNA version and mapping it uses, whether it normalizes input, and whether it logs the converted domain. A vendor who can't answer these has a gap worth noting, as covered in our guide to red flags when choosing an email verification service.
Bottom line: The wrong mapping rule can turn a dead domain into a live, unrelated one, so conversion behaviour matters more than a "supports international" checkbox.
Do you need to convert domains yourself before uploading?
Not if the verifier converts correctly and documents how it does so. Pre-converting makes sense when you run a data pipeline with a library you control and can test.
If you pre-convert, keep the original domain and the converted domain in separate columns. When a result looks wrong, you can trace it to the exact string that was queried. Confirm which IDNA version your library uses before running the job, and apply the same version to every file. Mixing versions across uploads makes results impossible to compare.
Bottom line: Pre-convert only if you can test and document the conversion yourself. Otherwise, verify the tool's behaviour with a control set.
Which verification approach fits an international list?
Five practical options exist, and the right one depends on how much of your list is non-ASCII. Best email verification tools differ most on exactly this point, so the table is a good starting filter.
| Approach | Handles IDN domains | Handles UTF-8 local parts | Main risk | Best fit |
|---|---|---|---|---|
| Upload raw UTF-8 CSV to a general verifier | Depends on the tool's conversion | Depends on the receiving server | Silent conversion errors you won't see | Lists that are almost entirely ASCII |
| Pre-convert domains to punycode before upload | Yes, if your conversion uses IDNA2008 | Unchanged, since the local part isn't converted | Using a library with the older mapping | Teams with a data pipeline and developer support |
| Split out EAI rows for separate review | Not applicable | Isolates the problem | Manual review workload | Lists with a meaningful share of UTF-8 local parts |
| Verifier with documented IDN and SMTPUTF8 handling | Yes, if documented and tested | Yes, if the server supports it | Vendor claims that aren't tested on your data | Mixed-language B2B and ecommerce lists |
| ESP built-in validation | Usually syntax-level only | Usually not checked | Typically can't confirm the mailbox exists | Quick syntax screening, not cleaning |
The ESP row matters for teams that rely on their sending platform. Our guide on whether your ESP's built-in verification is enough explains the gap in more detail.
Email verification for ecommerce and SaaS teams often hit this problem first, because signups arrive from many markets at once.
Unlimited Verifier fits the upload-and-verify approach. Standard verification is unlimited on every plan, so you can rerun a control set after every change at no per-email cost. What it doesn't do is document IDN or SMTPUTF8 behaviour, so the control test below is what confirms it. If two tools disagree on your control rows, running a second verifier on those rows is a reasonable tiebreaker.
Bottom line: Choose by the share of non-ASCII rows, and by whether you can verify the tool's behaviour yourself.
How do you test whether a verifier handles international addresses?
Vendor claims are cheap, so test the tool on addresses whose answers you already know. Before you shortlist vendors, work through our questions to ask before buying an email verifier. Then build a control set, which takes about an hour.
Build 25–30 control addresses with known outcomes. Include:
- 5 plain ASCII addresses you know are live (ask a colleague to confirm).
- 5 known-dead ASCII addresses.
- 5 IDN domains you know resolve, including at least one with accented Latin characters.
- 5 mapping-sensitive domains, such as those containing
ß, where the registered name is confirmed. - 5 EAI addresses you know are live, if your team has access to a UTF-8 mailbox. If not, note that and skip them.
- 5 known-dead addresses on IDN domains.
Record the expected result for each row in a separate column. Ground truth should come from a confirmed mailbox or registration, never from the tool itself.
Run the control file through the verifier. Save it as UTF-8 with a BOM.
Score two error types separately:
- False Invalid on known-live addresses.
- False Valid on known-dead addresses.
Log both in a comparison checklist so vendors are scored on the same rows.
Set your threshold. Treat any false Invalid on a known-live control as a blocker for international lists. A false Valid on a mapping-sensitive domain is also a blocker, because it means the tool may be checking the wrong domain.
Read the code if you can. The open-source engine on GitHub lets you inspect how a verifier prepares domains before the DNS query. Confirm the conversion logic yourself rather than assuming it.
Bottom line: A 30-row control test with known answers tells you more about international accuracy than a feature list does.
How do you verify an international list with Unlimited Verifier?
Follow these steps on a real list. Plan limits are noted where they apply.
- Export from your source as UTF-8 with a BOM. Excel can mangle accented characters in UTF-8 files saved without a BOM. Keep the original file for your suppression records.
- Separate the non-ASCII rows. In Excel, filter for emails containing non-ASCII characters. In Python, the test is
any(ord(c) > 127 for c in email). Save these rows as their own file. - Sign up for a free account. Before committing, compare email verification pricing against your monthly volume. The Free plan covers 25 lists a month of up to 150 emails each, plus 750 deep verifications a month, but has no API access. The Pro plan is $29 a month, or $25 a month billed annually. It takes lists of up to 25,000 emails, includes 25,000 deep verifications a month, and includes API access for 100,000 emails a month.
- Upload and verify a list. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically. Check the detected column on your international rows before you run the job.
- Run the control file first. Confirm the results match your expected outcomes before processing the full list.
- Choose your depth. Standard verification is unlimited on every plan with no per-email fees. Apply deep verification to the international subset, where extra checking matters most.
- Read the buckets. Valid addresses are safe to use. Invalid addresses should be removed, but review EAI Invalids first. Catch-all domains are flagged so you can hold them back from the first send, as explained on the catch-all email verification page. If you need the reason behind every failure, weigh a tool built for that, such as the best email verifier that shows why an email failed.
- Spot-check individual addresses. Use the free single-email checker for any address that surprises you.
- Export before results expire. Results are kept for 24 hours on the Free plan and 30 days on Pro, so download your Valid, Risky and Invalid files as CSV, Excel or JSON promptly. Unlimited Verifier has no native ESP, CRM or Zapier integrations, so re-import Valid addresses manually or call the email verification API from your own scripts. On Pro, API requests take bulk batches of up to 10,000 emails, which suits email verification API and automation workflows.
Bottom line: Separate, control-test, verify, review the EAI rows, then export before the results expire. The order matters more than the tool.
What does verifying a 10,000-row list with international addresses look like?
The figures below are illustrative, not measured results. The plan limits and arithmetic are real.
The list: 10,000 B2B contacts, of which 600 have IDN domains and 120 have UTF-8 local parts. That's 720 international rows, or 7.2% of the list.
Plan fit:
- Pro, whole list: 10,000 rows fits in one list, since the cap is 25,000. Deep verifying the 720 international rows uses 720 of 25,000 monthly deep verifications, or 2.9%. At $29 for the month, spreading the fee across this one list works out to $2.90 per 1,000 rows.
- Free, whole list: 10,000 ÷ 150 = 66.7, so 67 lists. The Free plan allows 25 lists a month, which caps you at 3,750 rows. The full list won't fit.
- Free, international subset only: 720 ÷ 150 = 4.8, so 5 lists (150, 150, 150, 150 and 120 rows). That's 720 deep verifications, within the Free plan's 750.
Hypothetical results for the international subset:
| Subset | Rows | Valid | Risky | Invalid |
|---|---|---|---|---|
| IDN domains | 600 | 540 (90%) | 40 | 20 |
| UTF-8 local parts | 120 | 70 | 30 | 20 |
| Total | 720 | 610 (84.7%) | 70 | 40 (5.6%) |
What to do next:
- Don't delete the 40 Invalid addresses yet. Pull 10 of them and check the domain conversion. If a domain resolves after conversion, the failure is a verification error, not a dead address.
- Review the 20 EAI Invalids separately. If the reply text points to SMTPUTF8 or encoding, those rows are unresolved, not dead.
- Hold the 70 Risky addresses back from the first send, following the sequencing in our email list maintenance best practices guide.
- Re-import the 610 Valid addresses. A sales prospecting list built this way starts from a verified base, rather than from unchecked data.
Bottom line: Of the two plans, Pro is the only one that can process the full file in one run. The international subset alone fits within the Free plan's limits.
What mistakes make international verification results wrong?
- Trusting "supports international domains" without a control test. A feature claim doesn't tell you the conversion rule or the SMTP behaviour.
- Deleting every Invalid IDN address automatically. A conversion error looks identical to a dead domain.
- Saving the file without a BOM. Excel can corrupt accented characters before the verifier receives them.
- Converting domains with a library on IDNA2003 rules. That can turn
straße.deinto a different, existing domain. - Treating EAI rejections as proof the mailbox is dead. The receiving server may not support UTF-8 addresses at all.
- Skipping normalization. The same visible address can be encoded two ways and looked up as two different strings.
- Verifying only the ASCII rows. Errors cluster in the international rows, so they need the most review.
- Verifying once and never again. Addresses decay over time, so schedule re-checks, as described in our guide to the best email verifier for monthly list re-verification.
- Treating verification as proof of consent. A valid mailbox isn't an opted-in contact. For the wider picture, see email verification compliance and hygiene.
Bottom line: Most international-list errors come from unverified assumptions about conversion and server behaviour.
How we compared (and limitations)
This article is based on public documentation: the IETF RFCs covering SMTP, SMTPUTF8, punycode and IDNA, the Unicode UTS #46 specification, and the IANA root zone database. We haven't run controlled tests against any vendor's systems, and we haven't measured how often mail servers support SMTPUTF8.
Unlimited Verifier's plan details and feature list come from the company's own published information. It states 99.5% accuracy for deep verification. That is the company's stated figure, not an independent benchmark. Its published features don't specify IDN or SMTPUTF8 handling, so the control test above is the only way to confirm its behaviour on your data. The worked-example percentages are illustrative.
Bottom line: Don't rely on any vendor's accuracy claim for international addresses until you've tested it against known answers.
For the bigger picture, see our guide to how to choose an email verifier.
Punycode conversion worked example
| Input domain | Punycode form | Result if converted | Result if not converted |
|---|---|---|---|
| münchen.de | xn--mnchen-3ya.de | DNS resolves, MX found | No record, looks nonexistent |
| пример.рф | xn--e1afmkfd.xn--p1ai | DNS resolves, MX found | No record, looks nonexistent |
Steps: 1) Normalize the domain. 2) Convert each label to xn-- form. 3) Query MX on the converted name. 4) If no MX, fall back to the A record per RFC 5321. 5) Run the SMTP probe and log the converted domain.
Frequently asked questions
What is punycode in email verification?
Punycode is the ASCII encoding that turns internationalized domain names into xn-- labels so DNS can resolve them. A verifier must convert the domain to punycode before querying DNS and MX records, or a live domain can be reported as nonexistent.
Why does my verifier mark valid international emails as invalid?
The most common cause is that the tool queries raw Unicode instead of the punycode form, so DNS returns no record. Other causes include skipped MX fallback to the A record and the receiving server blocking SMTP probes.
What is SMTPUTF8?
SMTPUTF8 is an extension that lets mail servers accept non-ASCII characters in the local part of an address, the text before the @. Without server support, addresses with such characters cannot be delivered, so a verifier cannot confirm them reliably.
Does Unicode in the local part work the same as in the domain?
No. Unicode in the domain is handled by converting it to punycode, which DNS understands. Unicode in the local part requires the receiving mail server to support SMTPUTF8, and that support is not universal.
Can different libraries convert the same domain differently?
Yes. Conversion rules differ on certain characters, such as German sharp s (ß). A mismatched rule can send the lookup to a different real domain, which may produce a false Valid result.
How do I test whether a verifier handles international domains?
Build a control set of 25 to 30 addresses with known outcomes, including several IDN domains, a few non-ASCII local parts and some deliberately dead addresses. Run it through the verifier and compare results before cleaning a full list.
What is a catch-all domain and why does it matter for IDNs?
A catch-all domain accepts mail for any address, so the verifier cannot confirm that a specific mailbox exists. This applies to international domains as well, and such addresses may show as Valid even when the mailbox is not real.
Does the IANA root zone include non-Latin top-level domains?
Yes. The IANA root zone database lists internationalized top-level domains, such as .рф, which appears in its xn--p1ai punycode form. A verifier must handle these top-level labels the same way as any other IDN.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.