Cover: No DMARC record? Outlook.com can bounce your app emails with error 550 5.7.1

 

Since November 5, people who run small mail servers, SaaS apps and side projects have been posting the same bounce: 550 5.7.1 Message rejected: Message lacks SPF/DKIM/DMARC Auth Records, sometimes with (AS9031519) on the end. The recipient is always a consumer Microsoft address: outlook.com, hotmail.com, live.com or msn.com. The sending domain usually has one thing in common with the others. It has no DMARC record.

If your app sends a verification code, a magic link or a password reset email, this matters more than it first sounds. A 550 is a permanent failure. Your mail provider will not retry it, the user never sees the message, and from their side your app simply looks broken. Many of them will not email you about it. They will close the sign-up screen and move on.

This post covers what is known about the change, what is still unclear, and the exact steps to make your domain pass. The fix is one DNS record plus making sure the services that send as your domain are set up to match it. Most apps can do it in under an hour, and the record is free.

What is actually happening

The first reports date the start to November 5, 2026. Mail operators and DMARC vendors who tested it describe the same pattern:

  • Only consumer Outlook addresses are affected. One write-up found that a Microsoft 365 business mailbox still accepted mail from a domain with no DMARC record.
  • Small senders are hit too, far below the 5,000 messages a day that Microsoft uses as its bulk sender line.
  • Not every message bounces. Some go through, and some that bounced were accepted on a retry. A few successful test sends prove nothing.
  • Domains with working SPF and DKIM but no DMARC record are still affected.

The new bounce is less helpful than Microsoft's older one. Since May 2025, Outlook.com has rejected non-compliant mail from high-volume senders with 550 5.7.515 Access denied, and that bounce names the sending domain and states the authentication level it failed to meet. The new 5.7.1 text gives no detail beyond the three acronyms.

Is this a policy or a bug?

Nobody outside Microsoft knows yet. As of November 9, Microsoft had not published a postmaster notice, a blog post or a documentation change about it. DmarcDkim.com checked the Defender for Office 365 blog, the Outlook.com postmaster site and Microsoft Learn and found only the 2025 bulk sender rule; the AS9031519 code does not appear in Microsoft's documentation. Security Boulevard reported that Microsoft had acknowledged the problem as an ongoing service degradation under investigation, and its author leans toward a bug. A Microsoft Q&A moderator told affected users to send the full bounce to Outlook.com sender support.

So it could be a mistake that gets rolled back next week. It is still worth fixing today, for two reasons. First, the rule it resembles already exists in writing. Microsoft's April 2025 post on high-volume senders says domains sending more than 5,000 emails a day must pass SPF and DKIM and publish DMARC with "At least p=none" aligned with SPF or DKIM. A transactional app that grows will cross that line anyway. Second, the fix does nothing to mail that already works. A DMARC record with p=none asks receivers to take no action on failures; it only tells them you have a policy and where to send reports.

One thing that will not help: asking users to add you to their Safe Senders list. Microsoft's FAQ on the bulk sender rule says the Safe Sender list won't be honored for that enforcement, and the Q&A moderator gave the same answer for the new bounces.

Step 1: list everything that sends mail as your domain

Before you touch DNS, write down every service that puts your domain in the From address. DMARC checks the domain in the visible From header, so every one of these needs to pass SPF or DKIM for that domain. For a typical small app the list looks something like this:

  • Your auth provider: Supabase Auth, Firebase Authentication, Clerk, Auth0 or your own backend sending through SMTP.
  • A transactional email service, if you have one: Amazon SES, Postmark, Resend, SendGrid, Mailgun, Brevo.
  • Your own mailbox provider, such as Google Workspace or Microsoft 365, for support replies.
  • A newsletter or marketing tool.
  • Help desk software, billing receipts, and anything a contractor wired up that you forgot about.

If you are not sure, search your codebase and your environment variables for SMTP_, MAIL_FROM, from: and the names of the services above. An app built quickly with AI tools can end up with two senders without the owner noticing: the auth provider's built-in mailer for sign-up and a separate service someone added later for receipts.

Step 2: check what your DNS says right now

Three lookups tell you most of what you need. Run them from any terminal with dig installed (macOS has it by default):

# DMARC: one TXT record starting with v=DMARC1, or nothing
dig +short TXT _dmarc.yourdomain.com

# SPF: one TXT record starting with v=spf1 on the domain itself
dig +short TXT yourdomain.com | grep -i "v=spf1"

# DKIM: the selector comes from your provider (selector1, google, resend, s1...)
dig +short TXT selector1._domainkey.yourdomain.com
dig +short CNAME selector1._domainkey.yourdomain.com

An empty answer on the first line means you have no DMARC record, and your mail to Outlook.com addresses is exposed to these bounces. Two records starting with v=DMARC1 is also a problem: receivers treat duplicate DMARC records as invalid, which is the same as having none. The same goes for SPF, where a domain may have only one v=spf1 record. Firebase's own docs point this out: if you need several senders, combine them into one SPF record.

If you look after several domains, for client apps or old projects, a short script saves time. This one uses the dnspython package (pip install dnspython) and checks SPF, DMARC and a handful of common DKIM selectors for every domain you pass it:

#!/usr/bin/env python3
"""Check SPF, DMARC and common DKIM selectors for one or more domains."""
import sys
import dns.exception
import dns.resolver

SELECTORS = ["selector1", "selector2", "google", "default", "k1", "s1", "s2", "resend", "mail"]

def txt(name):
    try:
        answers = dns.resolver.resolve(name, "TXT")
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return []
    return ["".join(part.decode() for part in r.strings) for r in answers]

def has_record(name):
    for rtype in ("TXT", "CNAME"):
        try:
            dns.resolver.resolve(name, rtype)
            return True
        except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
            continue
    return False

def check(domain):
    print(f"\n== {domain}")
    spf = [r for r in txt(domain) if r.lower().startswith("v=spf1")]
    if not spf:
        print("  SPF:   missing")
    elif len(spf) > 1:
        print(f"  SPF:   {len(spf)} records (invalid, merge them into one)")
    else:
        print(f"  SPF:   {spf[0]}")

    dmarc = [r for r in txt(f"_dmarc.{domain}") if r.lower().startswith("v=dmarc1")]
    if not dmarc:
        print("  DMARC: missing  <- Outlook.com may bounce this domain")
    elif len(dmarc) > 1:
        print(f"  DMARC: {len(dmarc)} records (invalid, keep one)")
    else:
        print(f"  DMARC: {dmarc[0]}")

    found = [s for s in SELECTORS if has_record(f"{s}._domainkey.{domain}")]
    print("  DKIM:  " + (", ".join(found) if found else
          "none of the common selectors found (check your provider's selector)"))

if __name__ == "__main__":
    if len(sys.argv) < 2:
        sys.exit("usage: mailcheck.py example.com [more domains...]")
    for d in sys.argv[1:]:
        try:
            check(d.strip().lower())
        except dns.exception.DNSException as e:
            print(f"\n== {d}\n  lookup failed: {e}")

Run it as python3 mailcheck.py myapp.com oldproject.io. The DKIM line is only a hint. Providers use their own selector names, so "none found" means you should look up the selector in your provider's dashboard, not that DKIM is broken.

Step 3: publish a DMARC record that starts at p=none

Add a TXT record at your DNS host (Cloudflare, Route 53, Namecheap, GoDaddy, wherever your nameservers point). The name is _dmarc and the value is:

v=DMARC1; p=none; rua=mailto:dmarc-reports@yourdomain.com

Here is what each part does:

  • v=DMARC1 must come first. Without it the record is ignored.
  • p=none is the policy. It asks receivers to deliver mail that fails DMARC as they normally would. Microsoft's bulk sender rule accepts it as the minimum.
  • rua= is where receivers send daily aggregate reports, as XML attachments. Microsoft's FAQ says Outlook sends these reports to the rua address you list. Use a mailbox or alias you actually own, because the reports show every server sending as your domain, including ones you forgot.

Put the record at your DNS host, not inside your email provider's admin panel. If your company runs on Microsoft 365, the DNS record still lives with whoever hosts your domain's DNS. After saving, run the dig line from step 2 again until it returns the new value. Most hosts publish it within minutes, but caches can take longer.

A side note if you read older DMARC guides: the standard was updated this year. RFC 9989, published in May 2026, obsoletes RFC 7489 and RFC 9091. It removes the pct tag and adds t (a test mode flag), np (policy for subdomains that do not exist) and psd. A record with only v, p and rua means the same thing under both versions, so the starter record above needs no change.

Step 4: make SPF or DKIM line up with your From domain

A DMARC record is not enough on its own. For DMARC to pass, SPF or DKIM must pass for a domain that matches the one in the From header. This matching is called alignment. In the default relaxed mode, a subdomain such as mail.yourdomain.com counts as matching yourdomain.com, but your provider's domain does not.

This is where many app setups quietly fail. Two common cases:

The SPF case. SPF is checked against the envelope sender, the address in the Return-Path header, which bounces go to. Many sending services use their own domain there by default, something like bounces.provider.net. SPF passes, but for the provider's domain, so it does not align with yours. The fix is your provider's custom return path or custom MAIL FROM setting, which puts a subdomain of yours in that header. Amazon SES calls it a custom MAIL FROM domain; other services have their own names for it in the domain settings.

The DKIM case. Your provider signs every message, but with its own domain unless you verify yours. Microsoft 365 is the well-known example: until you enable DKIM for your custom domain, it signs with your onmicrosoft.com domain, which does not align. DmarcDkim.com notes that without your own DKIM, DMARC then rests on SPF alone, and forwarding breaks SPF. In Microsoft 365 you turn on DKIM for your domain in the Defender portal and publish the two CNAME records it gives you (selector1 and selector2). Most transactional providers work the same way: a domain verification page lists two or three DKIM records to add.

You need only one of the two to align, but set up both if you can. Microsoft's own wording is "align with either SPF or DKIM (preferably both)." DKIM survives forwarding, so it is the one to get right first.

If your sign-up emails come from Supabase

Check whether you ever set up custom SMTP. Supabase's documentation says the built-in email service is for exploration only: it refuses to deliver to addresses outside your project's team, the rate limit is "Currently this value is set to 2 messages per hour", and there is no delivery guarantee. If real users can sign up today, you have probably configured custom SMTP already, which means your mail actually goes out through whichever provider you plugged in. The DMARC and alignment work happens on that provider and in your DNS. Supabase's docs also tell you to "Set up and maintain DKIM, DMARC and SPF configurations" with your email provider.

If they come from Firebase Authentication

By default Firebase sends auth emails from a Firebase-owned address, so your own domain's DMARC record is not involved. If you switched to a custom domain, open Security, then Authentication, then the Templates tab, edit a template and use "customize domain". The console shows the TXT and CNAME records to add, verification can take up to 24 hours, and you finish with "Apply Custom Domain". Firebase's page does not mention DMARC, so you still need to add the _dmarc record yourself once your domain appears in the From header.

Step 5: test against a real Outlook.com inbox

Create a free outlook.com or hotmail.com address if you do not have one, trigger a real sign-up or password reset from your app, and open the message. In Outlook on the web, open the message's menu and view the message source or details, then look for the Authentication-Results header. You want to see three passes:

Authentication-Results: spf=pass (sender IP is ...) smtp.mailfrom=mail.yourdomain.com;
 dkim=pass (signature was verified) header.d=yourdomain.com;
 dmarc=pass action=none header.from=yourdomain.com;

Check the domains as well as the words. smtp.mailfrom and header.d should be your domain or a subdomain of it. If you see dmarc=bestguesspass, the receiver could not find a DMARC record and guessed; DmarcDkim.com points out this means you have no record, not that you passed. Repeat the test for each sender from step 1: sign-up, receipts and support replies may each travel through a different service.

Because the bounces are intermittent, one delivered message is weak evidence. The headers are the proof. If they show aligned passes, you have done what you can on your side.

Step 6: resend what bounced, and stop losing the next one silently

A 550 is permanent, so nothing will retry the messages that already bounced since November 5. Check your provider's logs or bounce events for the 5.7.1 text and decide what to do with those users. For verification and reset emails the cleanest option is often to let them request a new one, since the old links may have expired. If you send a manual follow-up, send it after your DNS changes are live and tested.

Then look at how your app handles a bounce in the first place, because this will not be the last time a receiver changes its rules. A few things worth adding if you do not have them:

  • Subscribe to your provider's bounce webhook or event stream and log the bounce text next to the user record. A spike of one error string after a date is easy to spot in a log and impossible to spot in support tickets.
  • On the "check your inbox" screen, show a resend button after 30 to 60 seconds and a short line asking people to check spam or try another address.
  • Do not mark an account as verified-pending forever. If a verification email hard-bounces, tell the user on next login that the email could not be delivered.

If bounces continue after your headers show aligned passes, DmarcDkim.com suggests sending the full bounce text to Microsoft through the Outlook.com sender support form. At that point the problem is on Microsoft's side, and a clear report with headers is the useful thing you can add.

Mistakes that undo the fix

These slips can leave you with a DMARC record that does not do its job:

  • Two DMARC records. Someone adds a new one instead of editing the old one, and receivers treat both as invalid.
  • Too many SPF lookups. SPF allows 10 DNS lookups, and every include: counts, including the ones nested inside your providers' records. Adding a third or fourth service can push you over, and SPF then fails. Microsoft's FAQ mentions this limit directly.
  • Jumping to p=reject on day one. A strict policy tells receivers to refuse failing mail, which will include any sender from step 1 that you have not aligned yet. Microsoft advises moving gradually, none, then quarantine, then reject, once your reports show every legitimate source passing.
  • Sending from a subdomain and checking the wrong record. If your app sends as notify.yourdomain.com, receivers look for _dmarc.notify.yourdomain.com first and fall back to the record on yourdomain.com. Either is fine, but know which one applies.
  • Forgetting the second sender. The auth emails pass, and the receipt emails from a different service bounce. Step 1 is there for this reason.

A ten-minute checklist

  1. List every service that sends with your domain in the From address.
  2. Run dig +short TXT _dmarc.yourdomain.com. If it is empty, add v=DMARC1; p=none; rua=mailto:you@yourdomain.com at your DNS host.
  3. Confirm you have exactly one SPF record and one DMARC record.
  4. In each sending service, verify your domain so DKIM signs with it, and set a custom return path if offered.
  5. Send a real auth email to an outlook.com address and check that spf, dkim and dmarc all pass with your domain.
  6. Find messages that bounced with 5.7.1 since November 5 and let those users resend.
  7. Read your first week of DMARC reports before you think about a stricter policy.

Whether Microsoft calls this a bug or a policy next week, the domain you end up with is in better shape: it meets the written bulk sender rule, it tells you through reports who is sending as you, and it is ready for a stricter policy later.

If you look after several client domains and want a starting point for small scripts like the checker above, my Python Automation Scripts Pack: 100 Useful Projects for Freelancers ($9) is a ZIP of 100 Python automation projects with source code, README files, sample input and output, and a PDF guide, covering jobs such as monitoring websites, cleaning CSV data and generating reports. It does not include a DMARC checker; the script in this post is the one to use for that.

Sources