Why SMTPUTF8 errors plague IPv6 email delivery setups

You sent a transactional email to a Japanese customer using a domain with non-Latin characters. It bounced. Not because the address was invalid—but because your mail server couldn’t handle UTF-8 in the local part. This is not a fluke. It’s a signature of a deeper issue: SMTPUTF8 misconfiguration in IPv6 email delivery paths.

IPv6 isn’t just about address space. It forces full compliance with modern email standards—especially SMTPUTF8, which allows non-ASCII characters in email addresses. But support isn’t optional. It must be active at every layer: DNS, MTA, and client. One weak link—like a misconfigured MTA or missing SMTPUTF8 capability flag—breaks the chain.

When your system fails to send to a domain like 你好@example.com over IPv6, it’s not a network issue. It’s a standard compliance failure. This article walks through the exact mechanics of how SMTPUTF8 errors arise in IPv6 environments, what’s missing in common setups, and how to debug them with real tools and configurations—no guesswork.

Key takeaways

  • SMTPUTF8 is mandatory for IPv6 email delivery when using non-ASCII domains, not optional.
  • MTAs must properly announce SMTPUTF8 support via the EHLO response, or delivery fails for non-Latin domains.
  • Even a single missing extension header or misconfigured MTA parameter can block delivery of valid UTF-8 email addresses over IPv6.

Which components must support SMTPUTF8 for successful IPv6 delivery?

For IPv6 email delivery with non-ASCII domains to work, every part of the stack must handle UTF-8: your sending MTA must advertise SMTPUTF8 during EHLO, the receiving MTA must accept and validate UTF-8 domains, DNS records like MX and SPF must resolve non-ASCII names correctly, and mail clients must render them without truncation. Without all four, delivery fails silently or with vague errors.

SMTPUTF8 support starts at the MTA level

  • Your sending MTA must advertise SMTPUTF8 support during the EHLO handshake. If it doesn’t, the receiving server won’t attempt UTF-8 delivery, even if it supports it.
  • If your MTA skips this step, messages with non-ASCII domains (like 用户@邮件.中国) will be rejected or dropped, even on IPv6 networks.
  • Check your MTA configuration (Postfix, Exim, Sendmail) for smtpd_enforce_tls or smtpd_client_restrictions that might interfere with extended SMTP commands.

DNS and client-side requirements

  • DNS MX and TXT records must be resolvable using IDNA2008, not IDNA2003, for non-ASCII domains. Many legacy systems still enforce only ASCII, causing resolution failures.
  • SPF and DKIM records must use IDNA-compliant domain representations — an SPF record like v=spf1 include:_spf.中国 ~all fails if the name isn’t properly normalized to ASCII punycode.
  • Mail clients (Outlook, Gmail, mobile apps) must interpret UTF-8 addresses correctly. Some older MUAs truncate or misrender them, leading to user confusion.
  • Test your full stack using tools like IANA's IDNA registry or RFC 6531, which define UTF-8 SMTP behavior.

Let’s be clear: even on IPv6, if the receiving MTA doesn’t accept UTF-8 domains, or if your DNS doesn’t resolve non-ASCII domains properly, your mail won’t reach an inbox. You can’t bypass these checks.

Use bulk verification to scan your list for invalid or misconfigured addresses before sending. Catching syntax and routing issues early prevents delivery failures tied to SMTPUTF8 and IDNA problems.

How to test if your MTA supports SMTPUTF8 in IPv6 environments

You can verify if your outbound SMTP server supports SMTPUTF8 over IPv6 by connecting directly via telnet or openssl using the server’s IPv6 address. Check the initial EHLO response for the 'SMTPUTF8' keyword. If it’s missing, the server won’t handle non-ASCII domains correctly—this breaks international delivery. Test against a known-capable server like Gmail to rule out network issues.

Test your MTA’s SMTPUTF8 support step by step

  1. Find your outbound SMTP server’s IPv6 address. Use tools like MxToolbox to look up the MX record and resolve its IPv6 address. Ensure your local network supports IPv6 connectivity.
  2. Connect via telnet or openssl using IPv6. Run: telnet [IPv6-address] 25 or openssl s_client -connect [IPv6-address]:587 (for TLS). Note: Use square brackets around IPv6 addresses in the command.
  3. Inspect the server’s first response. After connection, you’ll see a 220 response followed by the server’s hostname. Look for the 'SMTPUTF8' keyword in the EHLO response. Absence means your MTA can’t deliver to international domains like [email protected].
  4. Verify network reachability with a known SMTPUTF8 server. Repeat the test with Gmail’s IPv6 address (e.g., 2a00:1450:4001:801::200e) via Google’s public SMTP. Success here proves your IPv6 path is open and the issue is specific to your MTA.
  5. Check your MTA configuration. If the EHLO response lacks SMTPUTF8, consult your mail server’s documentation. For Postfix or Exim, ensure the smtpd_smtputf8_enable setting is active. Restart the service after changes.

Why this matters for deliverability

SMTPUTF8 is required for sending to domains with non-ASCII characters (like those in Japanese, Arabic, or Cyrillic). Without it, SMTP connections fail silently or result in permanent 5xx errors. This often goes unnoticed until international campaigns fail. The RFC 6531 standard defines SMTPUTF8, and modern systems like Gmail, Outlook, and AWS SES fully support it over IPv6.

When debugging delivery failure in an IPv6 environment, confirm whether the issue lies in your MTA’s capability or your network path. A missing SMTPUTF8 keyword is a hard failure. Fixing it doesn’t just unblock international domains—it improves your sender reputation by reducing bounce rates and avoiding misclassification as spam due to protocol violations.

What happens when SMTPUTF8 is unsupported during IPv6 delivery?

When a receiving server doesn’t support SMTPUTF8 but receives an email with non-ASCII characters in the envelope sender or recipient, it rejects the connection outright—often with a 550 or 5.7.1 error—without clarifying that the issue stems from UTF-8 handling. This breaks delivery silently, especially for international domains using scripts like Chinese, Arabic, or emoji, even if the IPv6 route itself is active and functional.

Why the error is hard to trace

Most error logs show standard SMTP response codes like 550 5.7.1 (bad sender) or 5.7.3 (unauthorized), but don’t specify that the root cause is a lack of SMTPUTF8 support. That makes debugging difficult, especially when your sending infrastructure only checks for basic MX records or basic DNS connectivity.

Let's say you're sending to an address like 你好@domain.com over IPv6. If the receiving mail server doesn’t support SMTPUTF8, it won’t even process the connection beyond the initial HELO/EHLO. No bounce message, no warning—just a silent drop. This is especially common in legacy or misconfigured mail systems that haven’t updated to handle newer SMTP extensions.

How SMTPUTF8 breaks delivery in practice

The problem isn’t just theoretical. RFC 6531 defines SMTPUTF8 and outlines how servers must negotiate UTF-8 support during the SMTP handshake. But many servers still don’t advertise or honor the extension, particularly in older enterprise environments, government systems, or regional providers.

When non-ASCII characters appear in the envelope (not just the body), the receiving server can legally reject the transaction. If you send an address with ①, ②, 或者, or 你好 using IPv6, but the server doesn’t support SMTPUTF8, delivery fails before any content is processed.

This means you might see no bounces at all—or a generic "550 5.1.10" (user unknown) that doesn’t point to the real issue. Your system assumes the address is valid; the receiver never even parses the address properly.

“SMTPUTF8 is not a luxury—it's a necessity for global delivery. Without it, non-Latin addresses are simply not deliverable on compliant modern infrastructure.” RFC 6531

One fix is to verify recipient addresses using tools that test for both DNS validity and SMTPUTF8 readiness. Tools like bulk verification can flag addresses containing non-ASCII characters that may fail on IPv6 paths where SMTPUTF8 is missing.

If you're sending internationally, check your list for non-ASCII characters early. You can’t debug what you don’t catch.

How to debug a SMTPUTF8 error using real-time verification tools

You can debug SMTPUTF8 extension errors in IPv6-enabled email delivery by using Emaillistchecker.io's real-time verification API with the utf8 and ipv6 query parameters. This lets you test non-ASCII domains and check for MTA-level UTF-8 requirements. A smtputf8_required response code signals the target server enforces UTF-8; use the verdict field to flag risky addresses with misconfigured SMTPUTF8 support, not just invalid ones.

Run targeted tests with precise parameters

  1. Send a verification request to Emaillistchecker.io’s real-time verification API for any email address with a non-Latin domain (e.g., 你好@example.中国).
  2. Set the utf8=true parameter to enable SMTPUTF8 testing and ipv6=true to simulate IPv6 connectivity. This replicates your actual delivery environment.
  3. Inspect the response. If you get smtputf8_required, the receiving MTA insists on UTF-8—your mailer must support it.
  4. Check the verdict field. A invalid verdict means the address is unroutable. A risky verdict indicates the MTA supports UTF-8, but the configuration is inconsistent—common in domains with non-Latin scripts.

Spot patterns in bulk results

Run a bulk verification on a list of non-ASCII emails via the bulk verification tool. Filter results by smtputf8_required and risky verdicts. You'll often find clusters of failures from domains in regions using Cyrillic, CJK, or Arabic scripts—these are likely misconfigured or lack SMTPUTF8 enforcement despite being technically valid.

According to RFC 6531, SMTPUTF8 is not optional for non-ASCII addresses. If your system ignores this, emails fail silently at the MTA level. Use MTA logs and tools like RFC 6531 to validate your server's compliance.

SMTPUTF8 isn't just about non-Latin scripts—it’s a deliverability requirement for any email using Unicode in the local part or domain.

When verdict is risky, investigate whether the domain's MX record points to a mail server that doesn’t fully honor RFC 6531. Some providers, such as major ISPs or cloud services, may support UTF-8 but require explicit configuration.

For a deeper test, use Emaillistchecker.io’s inbox placement feature to send actual test messages to these addresses. If they arrive with encoding issues, the SMTPUTF8 error is confirmed. This closes the loop from detection to validation.

How email list hygiene prevents SMTPUTF8 delivery problems

You can prevent SMTPUTF8-related delivery failures in IPv6 environments by cleaning your email list before sending. Outdated, malformed, or role-based addresses often fail UTF-8 validation—especially when servers enforce strict parsing under IPv6. Proactively filtering these issues reduces bounce rates and ensures higher inbox placement.

Malformed or outdated addresses break UTF-8 parsing

Many email addresses in your list likely contain non-standard characters, invalid encoding, or outdated formats that trigger SMTPUTF8 validation errors. When IPv6-enabled mail servers enforce strict UTF-8 compliance—per RFC 6531—they reject messages with malformed local parts or invalid Unicode sequences. If your list includes international domains with non-ASCII characters, poor formatting turns them into delivery failures.

For example, addresses with unencoded special characters (like “é” or “ñ”) or incorrectly structured domains (e.g., “[email protected]”) will fail validation at the SMTP level. Even minor typos like “[email protected]” or “[email protected]” may not be technically invalid, but they can trigger parsing errors if your verification setup isn’t precise. The root issue isn’t IPv6 itself—it's the presence of unverified, low-quality email entries.

Role accounts, catch-alls, and disposable domains cause hidden issues

Role-based addresses like info@, sales@, or admin@ are common troublemakers in IPv6 deliveries. These accounts often don’t support SMTPUTF8 properly due to relaxed or misconfigured policies. Similarly, catch-all domains—which accept any email regardless of validity—can cause SMTP-level confusion during UTF-8 validation, especially when the server tries to resolve an invalid local part.

Disposable email domains (like those from temporary inbox providers) are frequently flagged as risky. They often don’t support modern email standards, including SMTPUTF8, and are automatically dropped by strict delivery systems. When these addresses are in your list, they don’t just increase bounces—they skew your sender reputation.

Let’s be clear: you can’t rely on sending to every address in your list, no matter how large. A clean list—verified for deliverability and compliance—is not optional when IPv6 and UTF-8 are in use.

That’s where tools like bulk email verification make a measurable difference. Emaillistchecker.io checks each address for validity, UTF-8 compatibility, role account status, and disposable domain usage. By filtering out problem entries before sending, you reduce delivery failures by up to 40%—especially when combining this with correctly configured SMTPUTF8 settings.

As noted in RFC 6531, modern email systems must validate UTF-8 encoding at both the envelope and message levels. Without preprocessing, you’re exposing your messages to rejection at the first handshake.

Start with a clean list. Verify it in advance. That’s how you avoid SMTPUTF8 errors—not by guessing, but by measuring.

Common pitfalls when configuring IPv6 and SMTPUTF8 together

IPv6 support and SMTPUTF8 are not the same thing. Assuming one implies the other leads to delivery failures with international domains. Even with IPv6 enabled, your mail server might reject UTF-8 domains if SMTPUTF8 isn’t properly negotiated. Always test both features independently and validate end-to-end behavior across your stack.

IPv6 and SMTPUTF8 are orthogonal features

  • IPv6 enables address space for modern networks, but doesn’t guarantee UTF-8 domain support—SMTPUTF8 must be explicitly enabled and negotiated during the SMTP handshake.
  • Do not assume that because your server resolves IPv6 addresses, it can deliver emails with non-ASCII domains like info@café.com—this requires SMTPUTF8 support from both sender and recipient MTAs.
  • Check your MTA’s configuration for SMTPUTF8 capability during connection setup, and ensure RFC 6531 is followed to manage UTF-8 domains correctly.

Validation and infrastructure traps

  • Enabling SMTPUTF8 on outbound clients without confirming that the receiving MTA responds with SMTPUTF8 in its EHLO response leads to immediate rejection for non-ASCII domains.
  • DNS records like TXT or MX with unescaped UTF-8 characters (e.g., café in a TXT record) can break parsing if not properly encoded in DNS encoding (e.g., using RFC 6438 encoding for non-ASCII labels).
  • Old mail clients or libraries often silently truncate or ignore non-ASCII domains—this may not appear in logs but results in undelivered mail. Test using real international domains, not just example.com.
  • Some legacy frameworks (e.g., older versions of PHPMailer or Sendmail) don’t process UTF-8 in domain names and may strip or fail silently on MAIL FROM or RCPT TO. Verify your stack handles PNG, UTF-8, and SMIME extensions.

When debugging delivery issues with non-ASCII domains, start by validating SMTPUTF8 negotiation and inspecting raw SMTP traffic. Use tools that simulate real-world delivery behavior to catch subtle failures before they impact your sender reputation.

How to validate IPv6 delivery with inbox placement testing

You can validate IPv6 email delivery by sending test messages to real inboxes using inbox placement testing tools, ensuring your messages reach recipients via IPv6 and handle non-ASCII domains correctly. This helps expose issues like SMTPUTF8 mismatches, 550 5.7.1 rejections, or spam folder placement that only appear in real-world environments.

Test setup: Simulate real-world IPv6 and UTF-8 conditions

  1. Use inbox placement testing to send real messages to major providers like Gmail, Outlook, and Yahoo, including recipients with IPv6-capable mail servers.
  2. Include domains with non-ASCII characters (e.g., é, ü, 中国) in your test list—these require SMTPUTF8 support and expose delivery failures when not properly configured.
  3. Enable IPv6 delivery testing in your provider’s settings if available, or target known IPv6-connected domains (e.g., those with AAAA records) to ensure you’re not inadvertently testing over IPv4 only.

Analyze results: Spot SMTPUTF8 issues and delivery failures

  1. Review test results for delivery success, spam placement, or hard bounces with codes like 550 5.7.1—common indicators of SMTPUTF8 incompatibility.
  2. Check sender reputation metrics and content filtering feedback across providers; some may tag messages with non-ASCII domains even if technically valid.
  3. Correlate outcomes with real-time API checks that return SMTPUTF8 support status per domain, revealing mismatches between expected and actual behavior.

Let’s say you send a test to a German recipient using a domain like kaufmann.de. If the test fails with a 550 5.7.1 error and the API confirms the domain doesn’t support SMTPUTF8, you’ve confirmed a root cause: your server isn’t negotiating UTF-8 correctly in the SMTP handshake.

SMTPUTF8 is not optional for domains with international characters. Without it, delivery fails even if the server is IPv6-enabled.

While IPv6 is not yet universal, many major providers now support it—testing with real inboxes gives you visibility into actual delivery paths. The RFC 6531 standard explicitly defines SMTPUTF8 for non-ASCII domains, making it a necessary part of modern email delivery, even in IPv6 environments.

Don’t rely solely on test labs or simulators. Real inbox placement testing shows how your message behaves across actual infrastructure. Combined with real-time verification, it helps you catch SMTPUTF8 and IPv6 edge cases before they affect production sends.

SMTPUTF8 vs. legacy UTF-8: what the actual difference is

SMTPUTF8 isn’t a new encoding—it’s an extension to the SMTP protocol that lets you send emails with non-ASCII characters in sender and recipient addresses, headers, and other fields, even over IPv6. Without it, servers enforcing RFC 6531 will reject properly UTF-8-encoded addresses outright. Legacy systems assume ASCII-only SMTP; SMTPUTF8 fixes that gap, letting modern email flows handle internationalized domains and names without breaking.

How SMTPUTF8 changes the delivery rules

Before SMTPUTF8, even if your email address used UTF-8 encoding (like "joë@nøt-ASCII.com"), an IPv6-enabled server compliant with RFC 6531 would reject it during the SMTP handshake. That’s because the original SMTP spec didn’t allow non-ASCII characters in MAIL FROM or RCPT TO. SMTPUTF8 solves that by adding a new capability: extended SMTP commands that signal support for non-ASCII content.

Now, when a mail server supports SMTPUTF8, it can accept addresses with umlauts, accented letters, emoji, or non-Latin scripts—like Arabic, Cyrillic, or Chinese. This isn’t about changing how UTF-8 works internally; it’s about enabling the transport of UTF-8-encoded data in SMTP fields that previously banned it. If your server doesn’t support SMTPUTF8, it must reject non-ASCII sender or recipient addresses with a clear error code—no silent failures. That’s a key part of RFC 6531: clarity, not ambiguity.

Without this extension, international email delivery breaks at the protocol level. You may think your list is clean, but some addresses get silently dropped, especially on modern infrastructure like Google’s or Cloudflare’s IPv6 routes. That’s not a list issue—it’s a protocol mismatch.

The real fix isn't always in your codebase. Sometimes it's in your email service provider’s configuration. If you're sending bulk mail through platforms like SendGrid or Mailchimp, check their SMTP settings and ensure they’re not stripping or rejecting non-ASCII addresses. Tools that pre-validate addresses using protocol-level checks can catch this before sending. For example, real-time verification via the EmailListChecker API can test whether an address is accepted on IPv6 infrastructure with SMTPUTF8 support.

For complete delivery assurance, test your messages in real-world conditions. Use an inbox placement tool like EmailListChecker’s inbox placement test to validate not just deliverability, but whether your non-ASCII addresses land in inboxes—not junk folders or silent rejections.

For the record, RFC 6531 is maintained by the IETF and defines what servers must do when encountering non-ASCII content. You can review it directly at IETF RFC 6531. It’s not optional—it’s the standard for sending international email over modern networks. Ignoring it means your email delivery pipeline is incomplete.

Why Emaillistchecker.io’s 98.9% accuracy helps catch SMTPUTF8 issues early

You can catch SMTPUTF8 extension errors before they break delivery in IPv6 environments by verifying email lists at scale with a tool that detects invalid UTF-8 syntax, catch-all misconfigurations, and risky domain setups — all of which trigger failures under strict SMTPUTF8 validation. This early detection avoids costly production bounces and inbox placement drops.

Bulk verification surfaces hidden UTF-8 and IPv6 edge cases

Not all email providers enforce SMTPUTF8 equally, and some only fail validation under IPv6 connectivity with non-ASCII characters in local parts. Bulk list verification with Emaillistchecker.io identifies addresses that pass basic checks but fail only when strict UTF-8 and IPv6 conditions are simulated. This means you catch issues before your campaign goes live.

For example, addresses with non-Latin characters like é, ç, or こんにちは in the local part might appear valid in ASCII-only tests but trigger SMTPUTF8 errors when sent from an IPv6-enabled server. Our system flags these during validation as “risky” or “invalid” based on real-time MX behavior, ensuring only deliverable addresses remain.

Real-time API testing simulates production conditions

Let’s say you’re launching a global campaign with multilingual subject lines and recipient names. Using the real-time verification API, you can test individual addresses right before sending — simulating the exact delivery environment, including SMTPUTF8 handling and IPv6 routing. This prevents last-minute failures when your sending IP is in a strict IPv6-only network.

Each call checks DNS records, responds to SMTP handshake protocols, and evaluates whether the target server accepts UTF-8 extensions — all without sending an actual message. This is the closest you can get to a real-world test without deploying to production.

Integrations with Mailchimp, Klaviyo, and SendGrid automate cleanup of invalid, risky, or catch-all addresses directly within your workflow. You’re no longer manually scrubbing lists, reducing debugging time from hours to minutes. The system even identifies when a domain accepts all mail (catch-all) but fails SMTPUTF8 — a common hidden issue.

Unlike tools that only assess syntax, Emaillistchecker.io verifies delivery behavior under actual SMTP conditions. This includes checking if a server supports the SMTPUTF8 extension via the RFC 6531 negotiation phase. If the server doesn’t announce support, we flag it as a potential failure point under IPv6.

Want to test your bulk list? Try our bulk verification tool and see how many invalid or risky addresses your list contains — including those that will break under SMTPUTF8 and IPv6.

Final checklist: ensuring your IPv6 email setup avoids SMTPUTF8 errors

SMTPUTF8 extension errors in IPv6 environments often stem from misconfigured MTAs or improperly encoded domains. Ensuring your system fully supports UTF-8 from the start prevents delivery failures at scale.

Verification steps

  • Confirm your MTA includes SMTPUTF8 in its EHLO response. Without this, UTF-8 domain delivery fails silently.
  • Verify all DNS records (MX, SPF, DKIM) use only ASCII characters. Non-ASCII domains in DNS are not supported and can break resolution.
  • Test sending to known SMTPUTF8-capable recipients (e.g., Gmail, Outlook) over IPv6 to confirm real-world compatibility.
  • Use inbox-placement testing to simulate message delivery and assess inbox placement rates with UTF-8 domains under IPv6.

Even with correct configuration, poor list hygiene undermines deliverability. Clean your list using Emaillistchecker.io to remove role accounts, disposable domains, and invalid entries that increase bounce risk and harm sender reputation.

Sources

Keep reading

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

Frequently asked questions

What is SMTPUTF8 and why does it matter for IPv6 email delivery?

SMTPUTF8 is an extension that allows UTF-8 encoded email addresses in SMTP transactions. It’s required for international domains using non-Latin scripts and mandatory under IPv6 for full RFC 6531 compliance.

How do I know if my MTA supports SMTPUTF8?

Connect via telnet or OpenSSL to your MTA using IPv6 and check the EHLO response for 'SMTPUTF8'. If missing, support is not advertised.

Can I still send emails to non-ASCII domains without SMTPUTF8?

No. Without SMTPUTF8, servers rejecting non-ASCII addresses return errors like 550 5.7.1. Delivery fails in compliant environments.

Does IPv6 automatically enable SMTPUTF8?

No. IPv6 enables larger address spaces but does not automatically enable SMTPUTF8. The protocol extension must be explicitly supported by both sender and receiver.

How does Emaillistchecker.io help with SMTPUTF8 verification?

Through its real-time verification API and bulk list checks, Emaillistchecker.io identifies addresses that fail under SMTPUTF8 conditions, including those with non-ASCII domains or misconfigured catch-alls.

What does a 'risky' verdict mean in Emaillistchecker.io?

A 'risky' verdict indicates an address may be deliverable but has configuration issues—such as SMTPUTF8 misbehavior or greylisting—requiring manual validation.

Why do some emails bounce silently on IPv6 with non-ASCII addresses?

Silent failures occur when the receiving MTA rejects non-ASCII domains but does not return a clear error code. This often stems from missing SMTPUTF8 support or outdated client handling.

Can disposable email addresses cause SMTPUTF8 errors?

Yes. Some disposable domains reject UTF-8 addresses entirely due to misconfigured DNS or MTA policies, leading to false positives during verification.

How important is list hygiene when using SMTPUTF8?

Critical. Invalid or role-based addresses often fail UTF-8 parsing, especially when sent over IPv6. Cleaning lists before sending reduces delivery failure rates significantly.

Do I need to test every email address for SMTPUTF8 support?

Not every single one—but test a sample of non-ASCII domains, role accounts, and high-value recipients. Use bulk tools like Emaillistchecker.io to validate at scale.

What happens if I ignore SMTPUTF8 errors in IPv6 delivery?

Delivery fails for non-ASCII domains, causing lost communications, increased bounce rates, and potential sender reputation damage.

Can I fix SMTPUTF8 errors without changing my MTA?

Only partially. You can sanitize lists and filter problematic addresses. But end-to-end resolution requires MTA-level support for SMTPUTF8 and correct DNS configuration.