You open your inbox on Monday morning. An email with no text, a subject line reading “Report domain: example.com Submitter: google.com Report-ID: 4821730956173204811”, and a .zip attachment. No error message anywhere. Yet someone has just written to you about your domain.
That file is an aggregate DMARC report in the XML format defined by RFC 7489 (2015), replaced in May 2026 by RFC 9990 for the aggregate reporting part. For one day, it lists every IP address that sent mail using your domain, the number of messages, and the SPF and DKIM results. To know whether all is well, look at 3 fields: source_ip, count, and the dkim/spf pair. A complete example with 2 records follows, decoded line by line, with the basics of the DMARC protocol picked up along the way.
What lands in your inbox
Reports go to the address declared in the rua tag of the _dmarc DNS record. Every receiving server that has seen mail from your domain sends one per day, according to the Google Workspace documentation. Depending on your volume and the number of receiving domains, it can reach several hundred reports a day. That’s why Google recommends a dedicated mailbox or group for these reports.
A Google report is recognizable by its “Report domain” subject line and the name of its attachment:
Subject: Report domain: example.com Submitter: google.com Report-ID: 4821730956173204811
Attachment: google.com!example.com!1794096000!1794182399.zip
The file name follows the RFC 7489 convention, carried over by RFC 9990: receiver, affected domain, start and end of the period as Unix timestamps, separated by exclamation marks, with an optional identifier. The RFCs provide for an .xml or .xml.gz extension; some receivers, Google among them, send a .zip archive. The attachment holds a compressed XML file. Double-click it or run unzip (gunzip for a .gz) in a terminal: out comes an .xml file, readable in any text editor.
The unzipped file, in full
This report was built for the article: fictional domain example.com, IP addresses reserved for documentation (RFC 5737), made-up values. No real data. It follows the RFC 7489 schema; some senders omit optional fields. RFC 9990 adds new elements to it.
<?xml version="1.0" encoding="UTF-8" ?>
<feedback>
<version>1.0</version>
<report_metadata>
<org_name>google.com</org_name>
<email>noreply-dmarc-support@google.com</email>
<report_id>4821730956173204811</report_id>
<date_range>
<begin>1794096000</begin>
<end>1794182399</end>
</date_range>
</report_metadata>
<policy_published>
<domain>example.com</domain>
<adkim>r</adkim>
<aspf>r</aspf>
<p>none</p>
<sp>none</sp>
<pct>100</pct>
<fo>0</fo>
</policy_published>
<record>
<row>
<source_ip>192.0.2.10</source_ip>
<count>1842</count>
<policy_evaluated>
<disposition>none</disposition>
<dkim>pass</dkim>
<spf>pass</spf>
</policy_evaluated>
</row>
<identifiers>
<envelope_from>send.example.com</envelope_from>
<header_from>example.com</header_from>
</identifiers>
<auth_results>
<dkim>
<domain>example.com</domain>
<result>pass</result>
<selector>selector1</selector>
</dkim>
<spf>
<domain>send.example.com</domain>
<scope>mfrom</scope>
<result>pass</result>
</spf>
</auth_results>
</record>
<record>
<row>
<source_ip>203.0.113.77</source_ip>
<count>37</count>
<policy_evaluated>
<disposition>none</disposition>
<dkim>fail</dkim>
<spf>fail</spf>
</policy_evaluated>
</row>
<identifiers>
<envelope_from>example.com</envelope_from>
<header_from>example.com</header_from>
</identifiers>
<auth_results>
<spf>
<domain>example.com</domain>
<scope>mfrom</scope>
<result>fail</result>
</spf>
</auth_results>
</record>
</feedback>
The annotated file, block by block
report_metadata: who is writing and for which period
<org_name>google.com</org_name>
<date_range><begin>1794096000</begin><end>1794182399</end></date_range>
Google wrote the report: every figure that follows describes what Gmail and Google Workspace received, nothing else. The 2 numbers in date_range are seconds elapsed since January 1, 1970 at 00:00 UTC. Here: from November 8, 2026 at 00:00 to November 8, 2026 at 23:59:59, or 86,399 seconds. The command date -u -r 1794096000 (macOS) or date -u -d @1794096000 (Linux) confirms it.
policy_published: your policy, as the receiver read it
<p>none</p><sp>none</sp><adkim>r</adkim><aspf>r</aspf><pct>100</pct>
This is your DNS record copied into the report. p sets the policy: “none” blocks nothing, “quarantine” sends to spam, “reject” refuses. sp sets the policy for subdomains. adkim and aspf are r for relaxed, the default mode in RFC 7489: the validated domain can be a subdomain of the visible domain. pct gives the share of messages the policy applies to (an RFC 7489 tag that RFC 9989, from May 2026, files under historical tags in favor of a t tag), and fo gives the failure report options. If these values differ from what you published, the record has changed since, or lives on another domain.
record: one line per sending source
Each record block groups the messages that share the same IP and the same results. row carries the address and the alignment verdict. identifiers repeats the domain from the From field, the header_from. It also repeats the envelope address domain, envelope_from. auth_results details what SPF and DKIM checked: the signing domain (d= in the DKIM signature), the selector that points to the public key used, and the raw result.
| Field | Block | What it says | Worth checking? |
|---|---|---|---|
| org_name | report_metadata | Organization that produced the report (google.com) | No |
| report_metadata | Receiver’s contact address | No | |
| report_id | report_metadata | Unique report identifier | No |
| date_range | report_metadata | Start and end of the period, as Unix timestamps | Yes, to compare days |
| domain | policy_published | Domain the policy applies to | No |
| p, sp | policy_published | Policy for the domain and for subdomains | Yes, once |
| adkim, aspf | policy_published | Relaxed (r) or strict (s) alignment for DKIM and SPF | No |
| pct, fo | policy_published | Share of messages subject to the policy, failure report options | No |
| source_ip | record > row | IP address that sent the messages | Yes |
| count | record > row | Number of messages on this row over the period | Yes |
| disposition | policy_evaluated | Action applied by the receiver (possible values: none, quarantine, reject) | Yes |
| dkim, spf | policy_evaluated | DMARC result of each mechanism, alignment included | Yes |
| reason | policy_evaluated | Reason for an override: forwarded, sampled_out, trusted_forwarder, mailing_list, local_policy or other | If present |
| envelope_from | identifiers | Envelope domain (MAIL FROM) of the message | If SPF fails |
| header_from | identifiers | Domain visible in the From field | No |
| domain (dkim) | auth_results | Domain that signed the message (d=) | If DKIM fails |
| selector | auth_results | Name of the DKIM key used | If DKIM fails |
| result (dkim, spf) | auth_results | Raw result before alignment | If the verdict is surprising |
| domain, scope (spf) | auth_results | Domain tested by SPF and its type (mfrom or helo) | If SPF fails |
The verdict in one minute
For each record, go through these 3 points in order:
- source_ip: do you recognize this address? Run dig -x 192.0.2.10 +short to get its reverse DNS and compare it with the sending tools you use.
- count: how many messages? A source at 1,842 messages weighs on your sender reputation. An unknown source at 37 messages mostly points to a declaration gap or spoofing.
- disposition, dkim and spf in policy_evaluated: at least one of the two mechanisms must be pass.
First line of the example: 192.0.2.10, 1,842 messages with dkim pass and spf pass. DKIM is signed with example.com and the selector “selector1”, and SPF validates send.example.com, a subdomain that aligns in relaxed mode. Your ESP, the tool that sends your campaigns, is declared correctly. Nothing to do.
Second line: 203.0.113.77, 37 messages, fail on both. Nobody signed these messages with your domain, and the IP appears in no SPF record. The disposition is “none” because the published policy is “p=none”: Google received no instruction to block, so these 37 messages are not proof of protection.
The decision rule comes down to 2 cases. If the reverse DNS reveals a forgotten tool of yours, add it to your SPF. You can also enable its DKIM signing. If the IP matches nothing you use, you have a spoofing attempt or an unknown relay. Watch the count over several days. Google advises replacing p=none with quarantine or reject once you understand who sends with your domain. Under RFC 7489, the “pct=” tag let you move in steps: 10, then 50, then 100.
The 4 DKIM x SPF combinations
The same reasoning applies to every line of an aggregate report. 4 configurations come up again and again, each with its own reading.

| DKIM | SPF | DMARC result | Most common cause |
|---|---|---|---|
| Pass, aligned | Pass, aligned | Pass | Direct send from the infrastructure declared in DNS |
| Pass, aligned | Fail | Pass, via DKIM | Forwarding, mailing list, mailbox transfer |
| Fail | Pass, aligned | Pass, via SPF | Relay that doesn’t sign the message, or signature broken in transit |
| Fail | Fail | Fail | Domain spoofing or sending source misdeclared in DNS |
Only the 4th row calls for action. One case slips through this grid: a pass in auth_results can turn into a fail in policy_evaluated. DMARC compares the validated domain with the header_from. A tool that signs with its provider’s domain, or sends from a shared IP pool with its own envelope domain, passes SPF and DKIM without ever aligning. With aspf=s, even send.example.com would stop aligning with example.com.
SPF failing but DKIM passing: no alarm
A message forwarded or redistributed by a mailing list leaves from another IP: SPF fails, while the DKIM signature travels with the message and keeps DMARC green. The receiver sometimes notes it in the row, for example <reason><type>mailing_list</type></reason>. The Google documentation mentions accepting an unauthenticated message that passed ARC verification. An SPF that fails on your own IPs has a different cause, often the SPF limit of 10 lookups. On the Gmail side, since February 1, 2024, a domain sending more than 5,000 messages a day must set up SPF, DKIM and DMARC, and a “none” policy is enough (Google’s sender guidelines). On the Microsoft side, domains sending more than 5,000 emails a day to Outlook must pass SPF and DKIM in addition to DMARC since May 5, 2025, otherwise messages land in the “Junk” folder ahead of an announced rejection with the “5.7.515” error (Microsoft Tech Community announcement). Each mechanism is covered in detail in SPF, DKIM and DMARC.
Not receiving your DMARC reports
No file after 48 hours? Check these 5 points in order, from the most common to the most discreet:
- The record: dig TXT _dmarc.example.com +short must return a single value starting with “v=DMARC1”. With 2 DMARC records, the receiver abandons processing (RFC 7489, a rule carried over into RFC 9989).
- The tag: rua=mailto:dmarc@example.com. To receive reports by email, the address is written with the “mailto:” prefix. A semicolon separates each tag.
- The external address: if the mailbox belongs to another domain, that domain must publish an authorization TXT record. Name: example.com._report._dmarc.example.net. Value: “v=DMARC1;”. Without it, receivers ignore the address.
- The delay: RFC 7489 set a default interval of 86,400 seconds (the ri tag), or 24 hours. RFC 9989 asks for reports at least once a day. DNS propagation comes on top. Wait 48 hours after publishing the TXT record before diagnosing.
- The mailbox: a .zip or .gz attachment can be blocked by a filter or land in spam. A full mailbox rejects the following reports. A dedicated mailbox or group solves both problems.
One last case can’t be fixed: a receiver that got no message from your domain has nothing to report. A domain that sends nothing to Google will receive no Google report.
When to switch to an analyzer
Reading by hand is enough as long as a few files arrive per day. It becomes untenable at the scale Google describes: several hundred reports a day. The documentation then recommends a third-party service to receive and analyze the reports. An analyzer such as parsedmarc (open source Python under the Apache 2.0 license, self-hosted) or a managed service like dmarcian does the work of this guide for you: decompression, grouping by IP, reverse DNS, the evolution of count day after day. The open source software costs nothing but needs a server to administer. Managed services each have their own pricing grid: check the included volume before redirecting your reports to them.
A DMARC report says nothing about message content or domains close to yours. Forensic reports (the ruf tag) are a separate format, absent from this guide. Inbox-side reputation is read elsewhere: Gmail Postmaster Tools for Google, SNDS (Smart Network Data Services) for Microsoft. These blind spots are detailed in what DMARC can’t do. RFC 9989 changed several DNS tags: the DMARCbis tags lists the ones to review. To stop opening files by hand, domain monitoring reads DMARC reports and DNS records continuously. It also tracks the domain’s expiration.
Clean authentication doesn’t stop a poorly maintained list from pushing up the hard bounce rate and dragging down sender reputation. Run a sample of your next list through verification before sending.

