SPF lookup counter

Your SPF record,
counted lookup by lookup.

An SPF lookup counter follows every include in your SPF record and counts each term that needs a DNS lookup, because RFC 7208 allows 10 and turns anything past that into a permanent error. Type your domain, or paste a draft record before you publish it. You get the total, the sender that spends the most, and the term where the budget runs out.

It runs in your browser. The names it asks about go to public DNS, Google’s first and Cloudflare’s if Google’s does not answer, and never to us. The SPF record generator builds a record and counts the senders it knows, the DMARC checker and the DKIM checker read the other two, and the setup guide shows how all three fit.

RFC 7208 · section 4.6.4 Include tree · void lookups Checked 22 Nov 2026

By the Builderify team

SPF lookup counter Reads public DNS from your browser

Paste the value with or without the quotes. Your own record is read as typed, and the includes inside it are looked up, so this is how to test a draft before you publish it. Add the domain if the record has a bare a or mx.

Example results · nothing has been looked up yet
Within the limit yourbrand.com

3 of 10 lookups

Sample: three senders, one of them with a nested include

v=spf1 include:_spf.mailhost-one.example include:_spf.mailhost-two.example ~all
3 of 10 DNS lookups Within the limit
DNS lookups
3 (limit 10)
Void lookups
0 (2 recommended)
Address ranges
5 (free)
Ends with
~all (softfail)

Who spends the budget

  1. include:_spf.mailhost-one.example 1 lookup, #1
  2. include:_spf.mailhost-two.example 2 lookups, #2 to #3
The terms of the record in the order a receiver evaluates them, with the running count of lookups
#TermRecord at
1 include:_spf.mailhost-one.example yourbrand.com
2 address ranges costs nothing _spf.mailhost-one.example
2 include:_spf.mailhost-two.example yourbrand.com
1 address range costs nothing _spf.mailhost-two.example
3 include:_ranges.mailhost-two.example _spf.mailhost-two.example
2 address ranges costs nothing _ranges.mailhost-two.example
Problem yourbrand.com

14 lookups, over the limit of 10

Sample: four senders and two own-domain terms that add up to 14

v=spf1 include:_spf.crm.example include:_spf.helpdesk.example include:_spf.marketing.example include:_spf.shop.example mx a -all
14 of 10 DNS lookups Over the limit
DNS lookups
14 (limit 10)
Void lookups
0 (2 recommended)
Address ranges
7 (free)
Ends with
-all (fail)

Who spends the budget

  1. include:_spf.crm.example 3 lookups, #1 to #3
  2. include:_spf.helpdesk.example 3 lookups, #4 to #6
  3. include:_spf.marketing.example 3 lookups, #7 to #9
  4. include:_spf.shop.example 3 lookups, #10 to #12
  5. mx 1 lookup, #13
  6. a 1 lookup, #14
The terms of the record in the order a receiver evaluates them, with the running count of lookups
#TermRecord at
1 include:_spf.crm.example yourbrand.com
2 include:_a.crm.example _spf.crm.example
1 address range costs nothing _a.crm.example
3 include:_b.crm.example _spf.crm.example
1 address range costs nothing _b.crm.example
4 include:_spf.helpdesk.example yourbrand.com
5 include:_n1.helpdesk.example _spf.helpdesk.example
1 address range costs nothing _n1.helpdesk.example
6 include:_n2.helpdesk.example _spf.helpdesk.example
1 address range costs nothing _n2.helpdesk.example
7 include:_spf.marketing.example yourbrand.com
8 include:_s1.marketing.example _spf.marketing.example
1 address range costs nothing _s1.marketing.example
9 a:out.marketing.example _spf.marketing.example
10 include:_spf.shop.example yourbrand.com
11 include:_s1.shop.example 11th: permerror _spf.shop.example
1 address range costs nothing _s1.shop.example
12 include:_s2.shop.example _spf.shop.example
1 address range costs nothing _s2.shop.example
13 mx 1 mail server yourbrand.com
14 a yourbrand.com
  • ! RFC 7208 (section 4.6.4) says implementations must limit the terms that need a DNS lookup to 10 and must return a permanent error past that. This record needs 14 if no term matches early. The 11th is include:_s1.shop.example in _spf.shop.example. A receiver stops at the first term that matches the sending server, so mail from servers listed before that point still passes, and mail that only a later term would authorise gets the permanent error instead.
Problem yourbrand.com

include:_spf.retired.example has no SPF record

Sample: a retired sender, a ptr, a duplicate and terms in the wrong place

v=spf1 include:_spf.mailhost-one.example include:_spf.mailhost-one.example include:_spf.retired.example ptr -all ip4:203.0.113.9 redirect=_spf.mailhost-two.example
4 of 10 DNS lookups Permanent error
DNS lookups
4 (limit 10)
Void lookups
1 (2 recommended)
Address ranges
2 (free)
Ends with
-all (fail)

Who spends the budget

  1. include:_spf.mailhost-one.example 1 lookup, #1
  2. include:_spf.mailhost-one.example 1 lookup, #2
  3. include:_spf.retired.example 1 lookup, #3
  4. ptr 1 lookup, #4
The terms of the record in the order a receiver evaluates them, with the running count of lookups
#TermRecord at
1 include:_spf.mailhost-one.example yourbrand.com
1 address range costs nothing _spf.mailhost-one.example
2 include:_spf.mailhost-one.example duplicate yourbrand.com
1 address range costs nothing _spf.mailhost-one.example
3 include:_spf.retired.example no SPF record yourbrand.com
4 ptr deprecated yourbrand.com
ip4:203.0.113.9 after all: ignored yourbrand.com
redirect=_spf.mailhost-two.example redirect ignored: has all yourbrand.com
  • ! RFC 7208 (section 5.2) says an include whose target publishes no SPF record gives a permanent error, so the whole check fails. yourbrand.com has include:_spf.retired.example, and _spf.retired.example publishes no record that starts with v=spf1. It may be a typo, or a service that stopped publishing one. Correct the name or remove the term.
  • ! include:_spf.retired.example returned nothing when looked up. A term like that can never match, still uses a lookup, and counts as one of the two void lookups RFC 7208 (section 4.6.4) recommends allowing.
  • ! RFC 7208 (section 5.5) says the ptr mechanism SHOULD NOT be published. It uses a lookup, and the answer depends on reverse DNS that the owner of the sending address controls. Replace it with the senders' own includes or address ranges.
  • ! RFC 7208 (section 5.1) says mechanisms listed after all are never tested and must be ignored, so ip4:203.0.113.9 in yourbrand.com does nothing. Move it before all or delete it.
  • i _spf.mailhost-one.example is included more than once. Each include is evaluated, so every copy uses its own lookups. Keep one.
  • i The redirect in yourbrand.com is ignored because the record also has an all term. RFC 7208 (sections 5.1 and 6.1) says a redirect must be ignored when there is an all mechanism, wherever the two are written.

The counter reads the record; it cannot tell you whether your mail passes SPF. Counting is per check, and a receiver stops at the first term that matches, so this is the most a message can cost, not what each one does cost.

01 / What counts

What counts toward
the SPF lookup limit.

RFC 7208 names the terms that cause DNS queries and says implementations must limit them to 10 “during SPF evaluation”. If the limit is exceeded, the implementation must return a permanent error.

The SPF terms, whether each costs a DNS lookup, and what RFC 7208 says about it
Term Costs a lookup? What the standard says
include Yes, and every counting term inside the record it points to It triggers a recursive evaluation of the other domain’s record (section 5.2). Only the result is used: a -all inside it does not end your check. If the target publishes no SPF record, the include is a permanent error.
a Yes, one An address lookup of the name, and it matches AAAA records too (section 5.3). With no name, it means the domain the record is published on.
mx Yes, one An MX lookup, then an address lookup on each mail server it returns (section 5.4). One mx term must not lead to more than 10 address lookups, or it is a permanent error. The same section says “the number of MX resource records queried is included in the overall limit of 10”; this counter counts each mx term once and shows how many mail servers it found, so treat a total of 8 or 9 with a multi-server mx as a minimum.
ptr Yes, one RFC 7208 says this mechanism SHOULD NOT be published (section 5.5). It looks up the reverse DNS of the sending address.
exists Yes, one An A lookup of the name you build, usually with macros, so it can depend on the sender’s address (section 5.7).
redirect= Yes, one, and the terms in the record it points to Hands the check to another domain’s record once every term has failed to match (section 6.1). It must be ignored when the record has an all term, wherever the two are written.
ip4, ip6, all No Section 4.6.4 lists them as the terms that cause no DNS query, so addresses are free however many you list.
exp= No It only causes a lookup “at a later time”, when a message is being rejected (section 4.6.4).

From RFC 7208 (sections 4.6.4, 5.1 to 5.7 and 6.1), read on 22 November 2026. To build a record and count the senders the generator knows, use the SPF record generator.

02 / How it is counted

Why four includes
can cost fourteen.

The limit is on the whole walk, not on the record you can see. Every include opens another company’s record, and the terms in it count against your 10, so a record with six lines can cost twice that.

Here is the second sample above, as a receiver counts it. The tenth lookup lands on the shop’s include, so mail that only the shop’s servers can send, and the two own-domain terms after it, get a permanent error.

The count, term by term made-up names
 1  include:_spf.crm.example
 2    include:_a.crm.example
 3    include:_b.crm.example
 4  include:_spf.helpdesk.example
 5    include:_n1.helpdesk.example
 6    include:_n2.helpdesk.example
 7  include:_spf.marketing.example
 8    include:_s1.marketing.example
 9    a:out.marketing.example
10  include:_spf.shop.example
11    include:_s1.shop.example  <- 11th: permerror
12    include:_s2.shop.example
13  mx
14  a
01The first record is free

Fetching the TXT record at your domain is not one of the terms section 4.6.4 lists, so it is not counted. Every include, a, mx, ptr, exists and redirect after it is.

02Includes open another record

RFC 7208 says an include triggers a recursive evaluation of the other domain’s record. Its terms are counted too, and so are the includes inside those. The standard adds that only the evaluated result is used, which is why a provider’s -all does not end your check.

03A match ends the check

Section 4.6.2 says processing ends at the first term that matches, so what one message costs depends on which sender it came from. The counter walks every term as if none matched, which is the most any message can cost, and a mail server listed late is the one that breaks first.

04all hides what follows it

Section 5.1 says terms after all are never tested, and that a redirect is ignored when the record has an all. The counter shows both as ignored and does not count them.

05Empty answers and copies count

A term whose name has no records still uses a lookup, and section 4.6.4 says implementations should allow only two such void lookups. The same include twice is evaluated twice, so a copy costs again.

From RFC 7208 (sections 4.6.2, 4.6.4, 5.1, 5.2 and 6.1), read on 22 November 2026.

03 / Over the limit?

Fix it in this order,
flattening last.

Flattening is the fix most pages lead with, and it is the one that needs upkeep. Start with the changes that cost nothing to maintain.

01

Remove what you no longer send from

Look at “Who spends the budget” and ask which of those services still sends as your domain. A service you stopped using still costs its lookups until its include is gone, and one that no longer publishes a record is a permanent error.

02

Give a bulk sender its own subdomain

RFC 7208 says receivers check the domain in the message’s envelope sender (the “MAIL FROM” identity, section 2.4), and the limit applies to each check. A service that sends with its own subdomain there is checked against that name’s record and gets a budget of its own. Its include then leaves your main domain’s count.

03

Prefer one service for one job

Two services that both send your newsletters mean two includes. The tree shows what each costs, so you can see whether dropping one frees four lookups or one.

04

Tidy the terms you wrote

Duplicates, an mx or a that no mail leaves from, and ptr each cost a lookup for nothing. The counter flags them. Addresses you own are free: list them as ip4 and ip6.

05

Flatten only what is stable

Flattening replaces an include with the addresses behind it. Both articles in the sources say the same thing about the cost: the copy is a snapshot, so when the provider adds a range you did not copy, mail from it fails SPF, and nothing tells you. Keep it for providers with few, documented addresses.

06

Mind the size, and who keeps it fresh

Flattened records get long. RFC 7208 says a record can be split into several strings (section 3.3) and that answers over about 450 octets may be silently ignored by some verifiers (section 3.4). A flattening service moves the upkeep to someone else, and, as dmarc.com notes, an include to that service comes back into your record.

From RFC 7208 (sections 2.4, 3.3 and 3.4), dmarc.com and DMARCengine, read on 22 November 2026.

04 / Read the result

What the counter says,
and what to do about it.

Each card quotes the rule behind its verdict. These are the six findings you are most likely to meet.

01

More than 10 lookups

The result is a permanent error (permerror), not a fail. The standard sets no rule for what a receiver does with it (section 2.6), so treat SPF as broken for the messages it affects. Mail that a term before the 11th would authorise can still pass, which is why the problem shows up for some senders and not others.

02

An include with no SPF record

Section 5.2 says an include whose target publishes no SPF record is a permanent error, and the checker marks the term and counts a void lookup when the name has no records at all. It is usually a typo, or a service you stopped using that stopped publishing one.

03

Two SPF records

Section 4.5 says that if a lookup returns more than one record starting v=spf1, the result is a permanent error. Adding a sender means editing the record you have, not adding a second one next to it.

04

Void lookups

A term that points at a name with no records still uses a lookup. Section 4.6.4 says implementations should stop at two void lookups and return a permanent error past that. A lone a or mx for a name you never set up is a common cause.

05

Terms after all

Section 5.1 says terms after all must be ignored. They are dead text, often an include someone added at the end of the record after it was already closed. Move it before all or delete it.

06

ptr

RFC 7208 says ptr SHOULD NOT be published (section 5.5). It uses a lookup, and the answer depends on reverse DNS controlled by whoever owns the sending address. List the sender’s include or its addresses instead.

From RFC 7208 (sections 2.6, 4.5, 4.6.4, 5.1, 5.2 and 5.5), read on 22 November 2026. If the record is fine and mail still lands in spam, the guide to business emails going to spam ranks the other causes.

05 / Where it runs

Where the lookup goes,
and what it cannot see.

Your browser asks Google Public DNS for each name, using its JSON API, and asks Cloudflare’s if that fails. Nothing goes to Builderify’s servers, but those resolvers see the names you ask about, as any DNS resolver would.

01It shows what resolvers return

The counter reads the published records, not your DNS host’s control panel. Resolvers cache answers for the record’s time to live, so a change from a few minutes ago may not show yet.

02It counts the worst case

It cannot know which server a message comes from, so it counts every term. A real receiver stops at the first match and may spend fewer lookups on a given message.

03Macros stay unfollowed

A term built with macros, such as the exists in a few large senders’ records, depends on each message. It is counted as one lookup and not followed.

04Large trees stop at 50

The counter stops following terms at 50 lookups. Anything past 10 is already a permanent error, and the page says when it stopped.

05Paste mode still looks up includes

A pasted record is read exactly as typed, but its includes are real names in DNS, so those are asked for. Nothing you paste is sent to us, and the “Domain it will be published on” box is optional.

Sending newsletters from Builderify?

Broadcast and Sequences send from your own domain, and the Domains page lists the exact records and checks them for you. The SPF record there is include:spf.builderify.net, and that name publishes only two addresses, so the include costs one lookup (read on 22 November 2026). Builderify’s setup also asks for an MX record, so on a domain whose mailboxes live at Google or Microsoft, send from a subdomain. Sending is 0.5 credit per email, and the 250 free credits every month cover 500 emails. See pricing.

Counted, then what?

SPF is one of three records. The DKIM checker reads the signing key, the DMARC checker reads the policy that ties them together, and the Gmail and Yahoo bulk sender guide says when each is required.

Questions

SPF lookups, before you ask.

RFC 7208 (section 4.6.4) says implementations must limit the terms that cause DNS queries to 10 during one SPF evaluation, and must return a permanent error if the limit is exceeded. The terms that count are include, a, mx, ptr and exists, and the redirect modifier. The count covers the whole walk, including terms inside the records your includes point to, not just the lines you can see.

Include, a, mx, ptr and exists, and the redirect modifier, each at least once. The terms inside an included record count too. The ip4, ip6 and all mechanisms and the exp modifier cost nothing, so listing addresses never uses the budget. The first lookup, for your own domain's TXT record, is not one of the counted terms.

The result is a permanent error (permerror) instead of pass or fail. RFC 7208 sets no rule for what a receiver does with that result, so treat SPF as broken for the messages it affects. A receiver stops at the first term that matches the sending server, so mail from a server listed before the 11th lookup can still pass while mail that only a later term would authorise gets the error.

Tools differ in what they count and how deep they follow macros. This one counts every term as if none matched, the most a message can cost, counts an mx term once and shows how many mail servers it found, and counts terms that use macros as one lookup without following them. RFC 7208 also says the number of MX records queried is included in the overall limit of 10, so a domain with an mx term that resolves several servers may count higher on a stricter reading. If you are at 8 or 9, treat the result as a minimum.

A DNS query for a term that returns no answer at all, or says the name does not exist. RFC 7208 (section 4.6.4) says implementations should limit void lookups to two and return a permanent error past that. A term like that can never match, so the usual fix is to remove it, or to correct the name if it was a typo.

Only for providers whose addresses rarely change. Flattening replaces an include with the addresses behind it, which costs no lookups, but it freezes a snapshot: when the provider adds a range you did not copy, mail from it fails SPF without any warning, as both dmarc.com and DMARCengine point out. It also makes the record long, and RFC 7208 says answers over about 450 octets may be silently ignored by some verifiers. Try removing unused senders and giving a bulk sender its own subdomain first.

The limit applies to each SPF check, and RFC 7208 says receivers check the domain in the message's envelope sender (the MAIL FROM identity). A service that sends with its own subdomain there is checked against that name's record, with a budget of its own, so moving a bulk sender to a subdomain takes its include out of your main domain's count.

No. Your browser asks Google Public DNS for each name, and Cloudflare's resolver if Google's does not answer, so nothing reaches Builderify's servers. Those resolvers do see the names you ask about, as any DNS resolver would. A pasted record is read as typed, and only the includes inside it are looked up.

Stop losing the visitors
you already paid for.

More leads from the traffic you already have, and follow-up that sends itself. Free to start. No card, no monthly fee.