How do you read a DKIM check result (selector, p=, k=, t=)?
AdminKit's DKIM check looks up one selector's TXT record — the label a mail provider assigns to one of several keys a domain publishes — and reading the result means checking p= for a valid base64 public key, k= for the signing algorithm, and whether an empty p= means the key was revoked rather than never published.
By AdminKit team, Netbase JSC · Updated
Key takeaways
- A DKIM check reads one record: the TXT record at
<selector>._domainkey.<domain>. It can’t list a domain’s selectors, so you have to bring the right one. - A present, valid-looking
p=means the public key is published. It doesn’t prove your mail is being signed with the matching private key. - An empty
p=is a deliberate revocation under RFC 6376 §3.6.1. Expected on a retired selector, alarming on one you still sign with. t=ymeans testing mode, and RFC 6376 tells verifiers to treat that mail like unsigned mail. Remove it once signing works.- “No record” usually means a wrong selector or a wrong domain, not a broken key. Read the
s=andd=tags from a real message to be sure.
What does AdminKit’s DKIM check show you?
AdminKit’s DKIM check takes two inputs, a domain and a selector, and queries the TXT record at <selector>._domainkey.<domain>. It keeps only TXT strings that contain a p= tag, since every DKIM key record has one, and then reports:
| Part of the result | What it contains |
|---|---|
| Record | The raw TXT value found, with multi-string records joined back into one string |
| Key type | The k= value, or rsa when k= is absent (the RFC 6376 default) |
| Public key finding | One of: key present and valid base64, key not valid base64, p= empty (revoked), or p= missing |
| Version finding | Only shown if a v= tag is present with a value other than DKIM1 |
| Testing finding | Only shown if the t= flags include y |
| Not found / multiple | No record at that name, or more than one record at the same selector |
The form also lists common selector names per provider, for example google for Google Workspace and selector1 / selector2 for Microsoft 365, for when you don’t know which one to try. The check does not measure key length, does not verify any message’s signature, and does not look at h=, s= or n= beyond listing them in the raw record.
Why does a DKIM result start with a selector, not just a domain?
Unlike an SPF or DMARC check, which reads a record at a fixed, predictable location for any domain, a DKIM check needs two inputs: the domain and a selector. RFC 6376 §3.1 describes DKIM’s key namespace as subdivided “using ‘selectors’” specifically because a domain can publish more than one key at once — one per sending service, or rotated over time — each under its own label, resolving to a DNS name like selector._domainkey.example.com. There is no DNS record that lists a domain’s active selectors; the value has to come from whoever configured mail sending, typically visible in that provider’s admin panel or, for a message you already have, in the s= tag of its DKIM-Signature header.
Here is a signature header quoted from the examples in RFC 8601 Appendix B.5. The two tags that matter for the lookup are s= and d=:
DKIM-Signature: v=1; a=rsa-sha256; s=gatsby; d=example.com;
t=1188964191; c=simple/simple; h=From:Date:To:Subject:
Message-Id:Authentication-Results;
bh=sEuZGD/pSr7ANysbY3jtdaQ3Xv9xPQtS0m70;
b=EToRSuvUfQVP3Bkz ... rTB0t0gYnBVCM=
A receiver verifying this message fetches the key from gatsby._domainkey.example.com, as RFC 6376 §3.6.2.1 describes. To check the same key with AdminKit, enter example.com as the domain and gatsby as the selector. The email header analyzer can pull these values out of a pasted header block, entirely in your browser.
How do you read an example record?
RFC 8463 Appendix A.2 publishes two example key records for the same domain, one Ed25519 and one RSA. They are quoted below and annotated:
brisbane._domainkey.football.example.com. IN TXT (
"v=DKIM1; k=ed25519; p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=")
test._domainkey.football.example.com. IN TXT (
"v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDkHlOQoBTzWR"
"iGs5V6NpP3idY6Wk08a5qhdR6wy5bdOKb2jLQiY/J16JYi0Qvx/byYzCNb3W91y3FutAC"
"DfzwQ/BC/e/8uBsCR+yz1Lxj+PL6lHvqMKrM3rG4hstT5QjvHO9PzoxZyVYLzBfO2EeC3"
"Ip3G+2kryOTIKT+l/K4w3QIDAQAB")
brisbane / test two selectors, two independent keys for one domain
v=DKIM1 version; optional, but if present it must come first
k=ed25519 / k=rsa key type; rsa is the default when k= is absent
p=... the base64 public key; the RSA one is split into four strings
Two things to notice. First, the selector is the only thing that differs in the name, so checking brisbane and checking test are two separate lookups with two separate results. Second, the RSA record is published as four quoted strings. RFC 6376 §3.6.2.2 says those strings “MUST be concatenated together before use with no intervening whitespace”, and AdminKit’s check does exactly that before it reads the tags.
What does each tag in the record mean?
RFC 6376 §3.6.1 defines the key record tags. The values each tag can take are registered in IANA’s DKIM parameters registry:
| Tag | Required? | Meaning | What to look for |
|---|---|---|---|
v= | Recommended | Version, must be DKIM1 and must come first | Any other value means receivers discard the record |
k= | Optional, default rsa | Key type: rsa, or ed25519 under RFC 8463 | Must match the algorithm your signer uses |
p= | Required | Base64 public key; empty means revoked | Present, unbroken base64 |
h= | Optional | Hash algorithms the key may be used with | If present, must include sha256 |
t= | Optional | Flags: y testing, s strict subdomain rule | y left on after rollout |
s= (service type, default *) and n= (notes for humans) also exist but rarely affect a result. Unknown tags are ignored, which is why a record with a typo in an optional tag can still verify.
What does the p= finding tell you?
A valid DKIM record’s most important field is p=, which holds the base64-encoded public key a receiver uses to verify a message’s signature. A result showing a well-formed p= value with a plausible length means the record is published and structurally correct — not that any specific message actually verifies against it, since that depends on the matching private key being used correctly by your mail server, which a DNS lookup can never see directly.
If the check says the key “does not look like valid base64”, look for characters that don’t belong: a space or line break inside a quoted string, a stray quote, or a value cut off part-way. RFC 6376 allows whitespace inside p= in some contexts, but a pasted key with an accidental break is the usual cause. AdminKit’s TXT record splitter splits a long value into correctly quoted 255-octet strings, which avoids the problem when you publish.
An empty p= value is a special case worth recognizing on sight: RFC 6376 §3.6.1 states that an empty value means the key has been deliberately revoked, not that it’s missing or broken. This is the standard way to retire a selector — the record stays published so a query doesn’t simply return nothing, but any mail still signed under that old key will now fail verification, which is the intended effect. Seeing an empty p= on a selector you recognize as retired is expected; seeing it on a selector you believe is still actively signing mail means that provider’s key was revoked without your sending stopping, which is worth investigating immediately. Rotating or revoking a DKIM key on a deliberate schedule, rather than leaving one in place indefinitely, is part of the email-authentication operational practice M3AAWG develops with mailbox providers and senders. How to rotate a DKIM key without breaking mail covers the order of steps.
What does the key type finding mean?
k= names the signing algorithm the key uses — almost universally rsa in current deployments, one of the values fixed by IANA’s DKIM parameters registry — and exists so a receiver knows how to interpret the p= value correctly rather than assuming a single fixed algorithm forever. AdminKit prints the value as “Key type”, and prints rsa when the tag is absent, because that is the default in RFC 6376.
ed25519 is the other registered type. RFC 8463 added it in 2018, and its keys are short: the base64 key is “only 44 octets”, as the example above shows. RFC 8463’s own example message carries two signatures, one RSA-SHA256 and one Ed25519-SHA256, each under its own selector. Signing twice like that lets a domain use Ed25519 without depending on every receiver supporting it.
For RSA, key length matters, and the check doesn’t report it. RFC 8301 says signers “MUST use RSA keys of at least 1024 bits” and “SHOULD use RSA keys of at least 2048 bits”, and that verifiers “MUST NOT consider signatures using RSA keys of less than 1024 bits as valid”. It also bans rsa-sha1 for signing. Google Workspace’s DKIM setup page offers 2048 and 1024 bits and recommends 2048 if your DNS host supports it. A 2048-bit key won’t fit in one 255-octet string, which is why long records arrive split.
What do t=y and t=s mean?
t= holds flags, separated by colons. AdminKit shows a finding only for y:
t=y(testing). RFC 6376 §3.6.1: “Verifiers MUST NOT treat messages from Signers in testing mode differently from unsigned email, even should the signature fail to verify.” In practice that means a testing selector gives you no enforcement. Some providers set it during initial setup. Leaving it on afterwards hides problems you’d want receivers to act on.t=s(strict). The domain in the signature’si=tag must equal thed=domain exactly, with no subdomains. RFC 6376 recommends it “unless subdomaining is required”. The check lists it in the raw record but doesn’t comment on it.
What does “no record” or “multiple records” mean?
A DKIM check returning no record at all for a given domain and selector combination has two likely explanations, and telling them apart matters: either that selector was never published at all (a typo in the selector name, or a provider that uses a different one than you guessed), or you’re querying the wrong domain — a signing service that sends on behalf of your domain sometimes publishes its selector under a third-party domain rather than yours, depending on how the sending relationship is configured. Confirm the exact selector and signing domain from your mail provider’s own setup documentation or a real message’s DKIM-Signature header rather than guessing at common selector names.
Receivers treat these cases differently, and the difference shows up in their headers. RFC 6376 §6.1.2 sets out what a verifier does:
| What the key lookup returns | Verifier outcome (RFC 6376 §6.1.2) | AdminKit check shows |
|---|---|---|
| No answer (timeout, server failure) | TEMPFAIL, may retry later | An upstream error; run the check again |
| The record does not exist | PERMFAIL, “no key for signature” | No record found at the selector |
| A record that doesn’t parse | PERMFAIL, “key syntax error” | p= missing, or not valid base64 |
An empty p= | PERMFAIL, “key revoked” | p= empty, selector revoked |
| More than one record | Results “undefined” under §3.6.2.2 | Multiple records, keep exactly one |
Some providers publish the selector as a CNAME that points at a key they host. Microsoft 365 works this way, with selector1._domainkey and selector2._domainkey pointing at Microsoft-managed names. The lookup follows the alias, so the check shows the TXT record at the end of it. If the alias exists but its target doesn’t, the result is “no record”.
What doesn’t the check tell you?
AdminKit’s DKIM check validates the published key record’s syntax; it does not and cannot confirm that any specific outgoing message is actually signed correctly, since that requires the message’s own headers, which the check never sees. RFC 6376 treats publishing a key record (§3) and a receiver verifying a signed message (§6) as genuinely separate steps — a syntactically perfect published record and a mail server that signs incorrectly, or not at all, are two different failure modes that look identical from a DNS lookup alone.
The receiver’s verdict lives in the Authentication-Results header of a message you received. RFC 8601 §2.7.1 defines the DKIM results a receiver can record there:
| Result | Meaning (RFC 8601 §2.7.1) |
|---|---|
pass | Signed, acceptable to the receiver, and verified |
fail | Signed and acceptable, but verification failed |
neutral | Signed, but the signature had syntax errors or couldn’t be processed |
policy | Signed, but some aspect wasn’t acceptable to the receiver |
temperror / permerror | Couldn’t verify, because of a transient or a permanent error |
none | Not signed |
If a published record checks out but mail still isn’t verifying for recipients, see DKIM selector and record mistakes that break signing for the most common causes beyond the record itself, and inspect a real sent message’s headers for a dkim=pass result as the final confirmation.
Checking your own setup
Run AdminKit’s DKIM check with your domain and the exact selector your mail provider assigned. Repeat it for every selector you sign with, because each is a separate record. For how DKIM fits together with SPF and DMARC as a complete mail authentication setup, see SPF, DKIM and DMARC explained, part of AdminKit’s broader email authentication cluster.
This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.
Frequently asked questions
Why does a DKIM check need both a domain and a selector?
Because DKIM keys are published per selector, not per domain, at a hostname like selector._domainkey.example.com, and RFC 6376 §3.1 defines no DNS record that lists which selectors a domain currently uses. The selector value comes from whoever configured mail sending — your mail provider's admin panel, or the s= tag in a DKIM-Signature header from a message that provider actually signed — not from anything discoverable by querying the domain alone.
The result shows a record with an empty p= value — is that a misconfiguration?
No — RFC 6376 §3.6.1 states plainly that an empty p= value means the key has been deliberately revoked, not that something broke. This is the expected, intentional way to retire a selector: the TXT record stays published (so a lookup doesn't just show 'missing'), but any mail still signed with that selector's old private key will now fail verification, which is exactly the point of revoking it.
What does the k= tag in the result tell me?
k= names the key's signing algorithm, almost always rsa in practice. It matters because a receiver verifying a signature needs to know which algorithm the public key in p= uses to interpret it correctly — a mismatch between the algorithm actually used to sign and what k= declares would cause verification to fail even if the key material itself is otherwise intact.
I see t=y in the result — what does that mean?
t=y marks the selector as being in 'testing' mode, a flag some mail providers set while a new DKIM key is first being rolled out. RFC 6376 §3.6.1 tells verifiers not to treat mail from a signer in testing mode differently from unsigned mail, even if the signature fails, so a testing selector gives you no enforcement. That is useful during initial setup, but t=y should be removed once you've confirmed signing and verification both work correctly in practice.
A valid record comes back from the check — does that guarantee my outgoing mail is signed correctly?
No. The check only confirms the public key record is published and syntactically valid in DNS — RFC 6376 treats publishing a key (§3) and a receiver actually verifying one signed message's signature against it (§6) as two separate steps. A valid published record says nothing about whether your mail server is currently signing outgoing messages with the matching private key; only inspecting a real sent message's headers for dkim=pass confirms that.
Sources
- RFC 6376 — DomainKeys Identified Mail (DKIM) Signatures
- RFC 6376 §3.6.1 — DKIM key record tags (the p= and revocation behavior)
- IANA — DKIM-Signature Tag Specifications (dkim-parameters registry)
- RFC 8301 — Cryptographic Algorithm and Key Usage Update to DKIM
- RFC 8463 — A New Cryptographic Signature Method for DKIM (Ed25519)
- RFC 8601 — Message Header Field for Indicating Message Authentication Status (Authentication-Results)
- Google Workspace Admin Help — Set up DKIM (default selector and key length)
- M3AAWG — Messaging, Malware and Mobile Anti-Abuse Working Group
Want AdminKit to watch this for you?
Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.
Talk to an expert
Huy Nguyen (David), Founder & CEO, Netbase JSC
Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.