Why does a DNS lookup return a different answer depending on which resolver you ask?
AdminKit's DNS lookup tool often shows different answers from different resolvers, and most of the time that's normal: independent caching, deliberate geo-steering toward a closer answer, a network-level block or substitution, or a validating resolver refusing an answer a non-validating one accepts. A mismatch is a starting point for diagnosis, not proof that either resolver is broken.
By AdminKit team, Netbase JSC · Updated
Key takeaways
- Two resolvers can give different answers for the same name at the same moment, and both can be right.
- Four causes explain most mismatches: independent caching, anycast or geo-steered answers, a network that filters or rewrites answers, and DNSSEC validation failing on one resolver only.
- Ask the domain’s authoritative nameserver directly. Its answer is what the domain actually publishes; every resolver answer is a copy or a decision made on top of it.
- SERVFAIL on one resolver and a normal answer on another usually points at DNSSEC. Repeating the query with checking disabled (
+cd) confirms it. - AdminKit’s DNS lookup gives one fixed reference resolver; the DNS propagation check compares four public resolvers at once.
Is a mismatch between resolvers a problem?
It’s tempting to treat a DNS lookup as a single, universal fact about a domain — query it once, get the answer, done. In practice, RFC 8499 (DNS Terminology; see also its IETF Datatracker record) defines a resolver as a piece of software that independently caches and serves answers, and nothing in RFC 1035 requires two different resolvers to agree at every moment. AdminKit’s DNS lookup tool queries Cloudflare’s public DNS-over-HTTPS resolver specifically, through an AdminKit Pages Function — a useful, independent reference point, but not necessarily identical to whatever resolver your own computer, phone, or network is currently configured to use. Seeing two different answers for the same name at the same time has several distinct, mostly benign explanations, and a smaller number of genuinely worth investigating ones.
| What you see | Most likely reason | How to confirm |
|---|---|---|
| Old value on one resolver, new value on another | Independent caching after a recent change | Compare the TTLs; ask the authoritative server |
| Different IP addresses, both belonging to the same provider | Anycast or geo-steered answers | Look up who owns each address; both serve the same site |
| An unrelated address, a block page, or no answer on one network only | The network filters or rewrites DNS | Ask an independent resolver from the same device |
| SERVFAIL on one resolver, an answer on another | DNSSEC validation failing on the validating resolver | Repeat with +cd; check the domain with a DNSSEC check |
Reason 1: how does independent caching cause a mismatch?
Every DNS record carries a TTL, and every resolver caches what it has already looked up for that TTL’s duration before re-checking the authoritative server. Two resolvers rarely cache the exact same record at the exact same moment, so if a record changed recently, one resolver may already show the new value while another is still serving a cached, older one until its own TTL expires. This is ordinary caching behavior, not a fault in either resolver — see DNS propagation and TTL explained for how long that window realistically lasts for a given TTL value, and the glossary entry on DNS propagation / TTL for how the two terms relate.
Reason 2: why do anycast and geo-steering give different answers?
Large, globally distributed services frequently return a different, equally correct answer depending on where the query appears to come from. This happens two ways: through anycast, where the same IP address is announced from many physical locations at once and ordinary internet routing delivers a connection to whichever location is topologically closest, or through geo-aware DNS responses, where the authoritative server reads the requesting resolver’s location — sometimes using the EDNS Client Subnet extension, which lets a resolver pass along a truncated version of the original client’s network to get a more locally relevant answer — and deliberately returns a nearby server’s address. Google Public DNS’s EDNS Client Subnet (ECS) guidelines explain that CDNs and latency-sensitive services use ECS to give accurate geo-located answers to lookups arriving through public resolvers, and warn that if even one authoritative name server for a zone does not implement ECS, its globally scoped responses quickly become the source of most cached data. Two people in different countries, or two resolvers in different data centers, can both receive a correct answer that happens to differ, because the whole point of the system is to answer differently depending on who’s asking and from where.
Reason 3: can a network deliberately change the answer?
Not every mismatch is accidental. Captive portals on public Wi-Fi, parental-control or content-filtering services, school and enterprise network policies, and some ISPs intentionally substitute a different IP address — frequently a block page, warning page, or simply no answer at all — for domains they’ve decided to restrict, rather than relaying the domain’s real, publicly published record. This is a deliberate policy decision at the network layer, not a DNS fault, and it’s one of the more common reasons a device on a restricted network sees a different answer than an independent lookup like AdminKit’s shows for the same name.
Reason 4: why does DNSSEC fail on only one resolver?
A resolver that performs DNSSEC validation checks the cryptographic signature chain behind an answer and refuses to serve it — returning SERVFAIL instead — if that chain is broken, expired, or misconfigured, specifically to avoid serving an answer it cannot verify as authentic. A resolver that doesn’t validate DNSSEC at all skips this check entirely and will return the same underlying answer without complaint, broken signature chain or not. Seeing SERVFAIL on one resolver and a normal answer on another, for the identical name, is a strong hint to check that domain’s DNSSEC configuration specifically — see DNSSEC: what it actually protects for what a broken chain actually looks like and why validation exists in the first place. One common cause is a stale DS record at the parent zone that a key rollover left out of sync with the domain’s current keys — exactly what CDS/CDNSKEY records exist to keep synchronized automatically, on registrars that support them. A resolver that supports Extended DNS Error (EDE) can turn that bare SERVFAIL into a specific reason code — a DNSSEC signature expired versus a name blocked by local policy look identical as a plain SERVFAIL, but distinct as EDE codes.
Which Extended DNS Error codes help tell the reasons apart?
RFC 8914 defines a numbered list of reasons a resolver can attach to an answer or an error. A client only sees them if the resolver sends them and the client displays them; recent versions of dig print them as an EDE: line. A few codes map directly onto the reasons above:
| EDE code | Name in RFC 8914 | Points to |
|---|---|---|
| 3 | Stale Answer | Caching: the resolver served an expired cached answer because it couldn’t refresh it |
| 6 | DNSSEC Bogus | DNSSEC: validation failed |
| 7 | Signature Expired | DNSSEC: an RRSIG’s validity window has passed |
| 15 / 16 / 17 | Blocked / Censored / Filtered | Network policy: the operator’s own blocklist, an external requirement, or one the client asked for |
| 22 | No Reachable Authority | The resolver couldn’t reach any authoritative server for the zone |
How do you compare resolvers yourself?
Work from the source outwards. First find the domain’s authoritative nameservers, then ask one of them directly, then ask each resolver you’re comparing. The commands below use dig; the addresses are documentation examples, so substitute your own resolver and the nameserver names your NS lookup returns.
Example commands (documentation names and addresses)
# 1. Which servers are authoritative for the zone?
dig example.com NS +short
# 2. What does the zone itself publish? (no recursion, straight from the source)
dig @ns1.example.net www.example.com A +norecurse
# 3. What does your own network's resolver say?
dig @192.0.2.53 www.example.com A
# 4. If step 3 returns SERVFAIL, repeat it with DNSSEC checking disabled
dig @192.0.2.53 www.example.com A +cd
Step 2 gives you the ground truth: if it shows the new value, the change is published and any other answer is a cache or a policy. Step 4 isolates DNSSEC. RFC 4035 (§3.2.2) says that when a query sets the CD (checking disabled) bit, a validating resolver “SHOULD, if possible, return the requested data” even if its own validation policy would reject it. If the plain query fails and the +cd query returns an address, validation is what failed, and the domain’s DNSSEC setup is where to look.
To compare several public resolvers without a terminal, AdminKit’s DNS propagation check queries Cloudflare, Google, Quad9 and OpenDNS at once and reports whether they agree.
What if your device disagrees with its own resolver?
Sometimes the resolver already has the new answer and one device still uses the old one. The difference sits on the device itself, which can answer a name before any resolver is asked:
| Layer on the device | What it does | How to rule it out |
|---|---|---|
Hosts file (/etc/hosts, or C:\Windows\System32\drivers\etc\hosts) | A fixed entry overrides DNS for that name, on that device only | Look for the name in the file and remove stale entries |
| Operating system cache | Keeps recent answers for their TTL | Windows: ipconfig /flushdns; Linux with systemd-resolved: resolvectl flush-caches |
| Browser cache | Some browsers keep their own short DNS cache and may use their own encrypted resolver | Restart the browser, or check its secure-DNS setting |
A hosts-file entry is the one to check first when a single machine disagrees with everything else, because it never expires. Command-line tools such as dig ask the resolver directly and skip the hosts file, so dig and a browser on the same machine can disagree for this reason alone.
How do you tell ordinary disagreement from a real problem?
Start by ruling out the boring explanation first: check the record’s TTL and how recently it (or anything upstream of it, like the domain’s nameservers) changed, since a short-lived mismatch during that window is expected, not a fault. If the domain is backed by a CDN or a large platform known to use anycast or geo-steering, a difference in IP address between two resolvers in different locations is normal and doesn’t need fixing at all. If you’re on a network you don’t fully trust — public Wi-Fi, a school or workplace connection — compare its answer against an independent resolver like the one behind AdminKit’s DNS lookup tool; a persistent, unexplained difference pointing at a block page or an unrelated address is worth investigating as filtering or, in the more serious case, as a hijacked router or resolver. Finally, if one resolver returns SERVFAIL specifically, treat that as a DNSSEC signal rather than a generic outage, and check the domain’s signature chain before assuming the resolver itself is at fault.
Encrypted DNS can also explain why a device and the network disagree: a browser using DNS-over-HTTPS to its own resolver bypasses the network’s resolver entirely. See DoH vs DoT for how that works.
Some free DNS lookup tools let you pick which resolver or nameserver answers a query instead of relying on one fixed resolver like AdminKit’s does — see best free DNS lookup tools for which ones confirm that on their own pages.
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
My DNS lookup tool shows a different address than the nslookup/dig command on my own computer — which one is correct?
Both can be correct at once. AdminKit's DNS lookup tool queries Cloudflare's public DNS-over-HTTPS resolver directly from an AdminKit Pages Function, while your own computer queries whatever resolver your operating system or network is configured to use — often your ISP's resolver, a VPN's internal resolver, or a corporate one. Each resolver independently caches answers and may be geo-steered to a different answer, so two different, currently-correct results from two different resolvers is expected behavior, not a bug in either tool.
Could my network be deliberately changing the DNS answer I get?
Yes, and it's one of the more common causes of a mismatch. Captive portals, parental-control services, enterprise security policies, and some ISPs intentionally substitute a different IP address (often a block page or warning page) for domains they filter, rather than returning the domain's real, publicly published answer. Checking the same name against an independent resolver, like the one AdminKit's DNS lookup tool queries, shows you what the domain actually publishes, separate from whatever your local network is doing to the answer in transit.
Why does a CDN-backed website resolve to a different IP address depending on where I check from?
Large content delivery networks intentionally return different answers to different resolvers so that each visitor is routed to a nearby edge server rather than one central one, either through anycast addressing (the same IP address is announced from many physical locations, and routing delivers the request to the nearest one) or through geo-aware DNS responses that read where the querying resolver is located, sometimes via the EDNS Client Subnet extension (RFC 7871). Two people in different countries querying the identical domain can correctly receive two different, perfectly valid IP addresses at the same moment.
A domain fails to resolve (SERVFAIL) on one resolver but resolves fine on another — why?
This is a classic sign of a DNSSEC validation failure on only one of the two resolvers. A resolver that validates DNSSEC checks the cryptographic signatures backing a DNS answer and returns SERVFAIL if the chain is broken or misconfigured, rather than risk serving a result it can't verify; a non-validating resolver skips that check entirely and happily returns the same (possibly broken) answer without complaint. See our guide on what DNSSEC actually protects for how that validation chain works and what breaks it.
Does AdminKit's DNS lookup tool show me exactly what my own device would get?
Not necessarily, and that's actually useful. It queries Cloudflare's public DoH resolver specifically, which gives you an independent, consistent reference point rather than a guarantee of matching whatever resolver your own device or network happens to be configured to use at that moment. Comparing AdminKit's result against what your device reports is itself a reasonable first diagnostic step when you suspect your local network's DNS path is doing something unexpected.
Sources
- RFC 1035 — Domain Names: Implementation and Specification
- RFC 8499 — DNS Terminology
- RFC 7871 — Client Subnet in DNS Queries (EDNS Client Subnet)
- Cloudflare — What Is Anycast?
- IETF Datatracker — RFC 8499, DNS Terminology (canonical document record)
- RFC 8914 — Extended DNS Errors
- RFC 4035 — Protocol Modifications for the DNS Security Extensions (the CD bit, §3.2.2)
- RFC 8914 — Extended DNS Errors
- RFC 4035 — Protocol Modifications for the DNS Security Extensions (the CD bit, §3.2.2)
- Google Public DNS — EDNS Client Subnet (ECS) Guidelines
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.