Article

Can an Email Verifier Check International Domains? Yes, If It Converts IDNs First

By Unlimited Verifier Team ·

Diagram showing an international email domain münchen.de converted to punycode xn--mnchen-3ya.de before an email verifier runs DNS and MX checks.

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

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:

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.

  1. 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.
  2. 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.

  3. Run the control file through the verifier. Save it as UTF-8 with a BOM.

  4. 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.

  5. 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.

  6. 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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Run the control file first. Confirm the results match your expected outcomes before processing the full list.
  6. 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.
  7. 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.
  8. Spot-check individual addresses. Use the free single-email checker for any address that surprises you.
  9. 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:

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:

  1. 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.
  2. Review the 20 EAI Invalids separately. If the reply text points to SMTPUTF8 or encoding, those rows are unresolved, not dead.
  3. Hold the 70 Risky addresses back from the first send, following the sequencing in our email list maintenance best practices guide.
  4. 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?

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 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.