DNS Changes Not Taking Effect? Compare Authoritative DNS Answers with Cached Results
You have saved a DNS record, but the browser still opens the old website. The first question is not “How much longer should I wait?” Instead, establish two things: whether the authoritative DNS servers actually used on the internet return the new value, and whether the user's recursive resolver still returns the old one. If the authoritative answer is wrong, waiting for caches to expire will not fix it. Only when the authoritative answer is correct but the recursive answer is old should you investigate TTLs, negative caching, and resolver behavior.
These issues usually arise somewhere between parent-zone delegation, authoritative DNS, recursive caches, and the client's resolution path. If all of these return the expected results but the browser still shows the old page, investigate connection reuse, HTTP caching, and CDN content caching rather than continuing to change DNS. In particular, updating A does not mean AAAA has also been updated, and an origin address shown in a DNS console is not necessarily the address returned in public DNS answers.
The following guidance explains principles and verification methods; it does not report measurements for a specific domain. The domains and IP addresses in the commands are documentation examples. Replace them with resources you are authorized to manage. Explanations involving provider proxying and HTTP caching are based on the linked product documentation and MDN documentation, without assuming that all services have the same default behavior.
First, determine whether you changed record data or authoritative server delegation
Changing the A record for www in a DNS console and changing a domain's NS settings at the registrar are different operations. The former changes a record within an authoritative zone; the latter changes the delegation through which the parent zone tells recursive resolvers which servers to query. Updating records only in a new provider's console does not mean external resolvers have started querying that provider.
For example, you update the address for www.example.com on a new DNS platform, but the parent zone still delegates example.com to the old platform. Direct queries to the new platform may return entirely correct results, while actual user queries are still answered by the old platform. This is not slow propagation of the new record: the new record is not yet part of the resolution path users actually follow.
The hostname is another common source of confusion. In a console, @ usually represents the current zone's apex. Changing example.com does not automatically change www.example.com. If a website first receives requests at the apex domain and then redirects to www, checking only one name can also lead to the wrong conclusion. When entering a full name, check whether the platform automatically appends the zone suffix, to avoid creating the record under a different name.
Before querying, establish at least the following from your change records: the full domain name, record type, old value, new value, change time, and old TTL. The most important item here is the “old TTL”: a new TTL cannot retroactively shorten the lifetime of an old record already stored in a recursive cache.
Use parent-zone delegation to find the authoritative DNS servers that actually answer
dig +trace shows the delegation chain, not the user's cache
Run the following in a terminal with dig installed:
dig +trace www.example.com A
This iteratively displays the query process from the root to the relevant zone. The important details are not simply whether an IP address appears at the end, but which NS names the parent zone returns, whether there is a delegation to a deeper subdomain, and which authoritative server ultimately answers. If www.example.com is in a separately delegated child zone, querying only the authoritative servers for example.com is not enough.
+trace does not reproduce the browser's DNS path. It bypasses the recursive cache normally used and requires the current network to allow direct access to external DNS servers. If a corporate network allows access only to internal resolvers, the trace may time out partway through. This alone does not prove that public delegation is broken. In that case, verify from an authorized environment that permits direct DNS queries.
An ordinary dig example.com NS query may return NS information from a recursive cache or reflect the NS records published by the zone itself. To determine whether a registrar change has taken effect, focus on the delegation actually returned by the parent-zone servers, rather than relying only on the console or the NS list from an ordinary query. If necessary, use the trace results to query a parent-zone server explicitly for the relevant name's NS records.
Parent-zone NS records, in-zone NS records, and glue are not interchangeable
Parent-zone delegation determines where resolvers initially send queries; in-zone NS records declare the zone's own authoritative servers. If these disagree, some resolvers may continue using old servers because of existing caches, while others reach the new servers, producing inconsistent results between users.
If an authoritative server's name is itself within the delegated domain—for example, ns1.example.com serves example.com—the parent zone generally also needs to provide glue addresses to help locate that server. When moving an NS host to a new address, changing only the in-zone A or AAAA record for ns1 does not necessarily update the glue managed through the registrar. If the parent returns an old address, queries may be sent to a server that no longer works.
An NS migration therefore requires separate checks of parent-zone delegation, any required glue, in-zone NS records, and the availability of both old and new authoritative services. Do not attribute every problem to the website's A-record TTL, or keep clearing the local cache after discovering that the parent still delegates to the old NS servers.
Query every authoritative DNS server directly to verify publication
Keep the status code, aa flag, and full answer section
After identifying the authoritative server addresses from the delegation chain, query them directly with recursion disabled:
dig @203.0.113.10 www.example.com A +norecurse
dig @203.0.113.10 www.example.com AAAA +norecurse
dig @203.0.113.10 www.example.com CNAME +norecurse
Here, 203.0.113.10 represents the authoritative server being checked, not the website's origin server. Repeat the queries against the other authoritative servers in the delegation. Do not start with only +short, because it hides status codes, flags, and server information—the very details needed to distinguish “no record” from “refused to answer” and “query failed.”
Check status and flags in the response header, along with ANSWER SECTION and AUTHORITY SECTION. For a name that the zone is authoritative for, a direct authoritative answer should normally include the aa flag. +norecurse merely asks the server not to perform recursion; it does not turn an arbitrary DNS server into an authoritative server. If aa is absent, determine whether you queried a caching server, received a referral, or contacted the wrong server.
The following answer-section line is provided only to illustrate the format:
www.example.com. 300 IN A 203.0.113.10
Its fields are the record name, TTL in seconds, class, record type, and record data, in that order. To determine whether a change has taken effect, compare the name, type, and complete record set—not just one IP address. A name can have multiple A or AAAA records, and a change in their returned order does not necessarily indicate a configuration change.
Check all authoritative servers in the same delegation
If one server returns the new address while another still returns the old one, the problem already exists at the authoritative layer. Recursive resolvers may receive different versions depending on which server they select. Even after clearing a cache, they may cache the old value again. The useful next step is to fix publication, zone synchronization, or network-specific record configuration, rather than continue waiting for the old TTL.
You can also query the zone's SOA:
dig @203.0.113.10 example.com SOA +norecurse
In environments using traditional primary-secondary zone transfers, differing SOA serials can help identify unsynchronized replicas. However, a managed DNS provider's internal publication architecture may not be reflected in traditional serials, and matching serials do not prove that all records are identical. Treat the serial as a supporting clue; the actual answers for the target name remain decisive.
Also check the console's default responses, carrier-specific responses, and geographic policies. If one network-specific configuration is updated but the default is not, some users may continue receiving the old value. Verify the conditions according to the product's rules rather than declaring that “all authoritative servers are updated” based on one query.
How to read cache TTLs when authoritative answers are correct but recursive answers are old
Query the recursive resolver the user actually uses
Run a query with the default settings:
dig www.example.com A
Check SERVER at the end to confirm which server the command actually queried. If it is a loopback address, you will usually also need to inspect the system resolver's upstream servers. On Linux, use resolvectl status where applicable; on Windows, check the DNS servers listed by ipconfig /all. VPNs, corporate networks, and routers may specify additional resolution paths.
Once you know the recursive resolver's address, query it explicitly:
dig @203.0.113.11 www.example.com A
dig @203.0.113.11 www.example.com AAAA
Here, 203.0.113.11 represents the recursive resolver being checked. Specifying a server makes repeated comparisons easier, but does not establish that the browser currently uses that resolver. If encrypted DNS is enabled in the browser, check its settings as well; system DNS results are not a substitute for browser DNS results.
A decreasing TTL suggests an old cache entry, not a universal countdown
Suppose all relevant authoritative servers return the new value, but a recursive resolver still returns the old one, with a TTL that generally decreases between queries. This is consistent with the old record remaining in its cache. Repeat a small number of queries a few tens of seconds apart and observe the record data and TTL; high-frequency requests are unnecessary.
If the old record was originally cached with a TTL of 3600 seconds, changing the new record's TTL to 60 seconds when you update the address does not immediately inform resolvers holding the old record. They may continue using the old value for its remaining cached lifetime. For a planned migration, lower the TTL in advance and allow existing long-TTL cache entries enough time to expire naturally before switching the address.
Do not treat a TTL observed in one query as the remaining wait for every user. Different resolvers cache records at different times. Large recursive services may have multiple cache nodes, and a single endpoint may not represent a single cache. Implementation details such as prefetching, minimum and maximum cache lifetimes, and serving stale answers during failures can also affect the TTL you observe.
If the TTL repeatedly jumps upward while the old value continues to appear, recheck all authoritative servers, old delegations, and network-specific configurations. Also consider different cache instances behind the recursive service. Only after ruling these out should you investigate whether the resolver is persistently serving expired data. A single TTL change does not prove “DNS hijacking” or that a provider has failed to update its records.
If a new record still cannot be found, distinguish negative caching from query failures
NXDOMAIN is not the same as having no A record
Deleting an old record and then recreating it, or creating a record for a previously nonexistent subdomain, can encounter negative caching. Recursive resolvers cache not only successful results but also certain conclusions that a name or record type does not exist. A new record remaining unavailable is therefore not necessarily a matter of the positive A-record TTL.
NXDOMAIN means the queried name does not exist. NOERROR with no answer for the requested type, after excluding referrals and similar cases, may mean that the name exists but that record type does not. This is commonly called NODATA. For example, if a name has only AAAA and no A, the absence of an address in an A query does not establish that the entire name is nonexistent.
Query both the authoritative server and recursive resolver for the same name and type, retaining the full output. Negative answers often include an SOA in the authority section. The negative-cache lifetime is generally constrained by both the SOA record's TTL and its MINIMUM field under the applicable rules, and the resolver may impose its own limits. Do not mechanically interpret the last number in an SOA as the final waiting time in every situation.
If the authoritative server returns the correct record but the recursive resolver still returns an old negative answer containing an SOA, investigate negative caching first. Lowering the new record's TTL does not actively delete a previously cached negative answer. On an internal resolver you manage, you can clear the relevant cache entries using supported product features. With public recursive resolvers, you generally need to wait for their caching policies to refresh the result.
SERVFAIL cannot be reduced to “wait for the TTL”
SERVFAIL indicates a resolution failure. Common areas to investigate include unreachable authoritative servers, DNSSEC validation failures, incomplete delegation, and transport problems. A timeout may mean that no explicit DNS error response was received at all. Neither means simply that “the cache still contains the old address.”
If you have just migrated DNS services, pay particular attention to whether the parent-zone DS matches the new zone's DNSSEC keys. A direct authoritative query returning an address while a validating recursive resolver returns SERVFAIL is a reason to investigate DNSSEC, but it is not conclusive by itself.
For recursive resolvers that support these options, you can perform read-only diagnostics:
dig @203.0.113.11 www.example.com A +dnssec
dig @203.0.113.11 www.example.com A +dnssec +cdflag
+dnssec requests related DNSSEC data; it is not itself a full local validator. +cdflag requests that checking be disabled for that query. If the first query fails and the second succeeds, that is a clue to a validation-chain problem. Then check the parent-zone DS, zone DNSKEY, and signature status. Do not treat permanently disabling validation as a fix. Adjust DS records and keys according to the hosting provider's migration procedure to avoid a broader resolution failure caused by an incorrect sequence.
Why you may still reach the old server after A has been updated
AAAA and the CNAME chain have their own update requirements
Dual-stack clients may use IPv6. If you update only A while AAAA still points to the old environment, browsers on some networks may continue connecting to the old service, even though IPv4-only commands look entirely normal. Update or retain the record types according to actual requirements; do not unconditionally delete AAAA just to make tests agree.
CNAME introduces independently cached records as well. Suppose www.example.com points to api.example.com. The former's CNAME and the latter's A and AAAA records have separate TTLs. You may have changed the alias target while the resolver still holds the old CNAME, or the CNAME may already point to the new target while the target address remains cached with its old value.
To investigate, query the authoritative servers for the alias's zone and the target name's zone separately. If the target is hosted by a different DNS service, the current domain's authoritative server has no obligation to recursively return the target's final address. Seeing only a CNAME in a +norecurse query should therefore not automatically be interpreted as incomplete resolution or a service fault.
Flattening and CDN proxying can change the form of public answers
If the console contains a CNAME but external queries show only A or AAAA records, CNAME flattening may be involved. If the console contains an origin IP but public answers contain proxy addresses, CDN proxying may be enabled. In these cases, an answer differing from the console value does not necessarily mean the change has failed.
For example, the Cloudflare DNS record type documentation describes proxy status for A, AAAA, and CNAME records, and CNAME records may also involve flattening. First establish whether a record is DNS-only or proxied, then decide which value the public answer should be compared with. Do not assume this product behavior applies to all DNS services.
If you changed only the origin behind a CDN, user-facing DNS addresses may not need to change at all. In that case, verify the proxy's origin configuration and actual application responses rather than expecting recursive resolvers to return the new origin IP. Conversely, a particular IP, CNAME, or response header alone is insufficient to establish the full delivery path.
If you are unsure whether public answers already point to a CDN, use CdnChart's provider identification and node verification tool to gather supporting clues, then compare them with the proxy status, CNAME target, and provider configuration in the DNS console. Detection results do not replace direct queries to every authoritative server, nor do they establish the complete delivery path or prove that the origin has been updated.
Why the browser still shows the old page when DNS results are correct
dig, the operating system, and the browser may use different resolution paths
dig generally sends DNS queries itself and does not fully reproduce how an application uses the system's name-resolution interfaces. The operating system may first match a hosts entry, use a local cache, or apply VPN split DNS to selected domains. The browser may also use its own DNS cache and encrypted DNS service. A correct terminal query proves only that the result of that particular query was correct.
Check for hosts-file overrides for the target domain, whether a VPN controls resolution, and the browser's secure DNS settings. Corporate internal domains may also use split-horizon DNS, where internal and external queries are intentionally expected to return different results. Before comparing them, confirm whether they should use the same view, so that normal internal/external differences are not mistaken for DNS poisoning.
The remote address for an individual request in browser developer tools can help establish where a connection went, but you must also consider proxy use, connection reuse, and whether a request was actually sent. If a page comes entirely from local cache, its contents alone cannot tell you whether a DNS lookup occurred.
Old connections and HTTP caches do not expire in step with DNS TTLs
DNS affects paths that require a fresh lookup and connection. An existing HTTP/2 or HTTP/3 browser connection may continue carrying requests. Long-lived connections such as WebSockets do not automatically migrate when a DNS record changes either. Even after the resolver updates, an existing connection may remain attached to the old endpoint.
Browser caches, CDN content caches, Service Workers, and page-history snapshots may also continue serving old pages. These are separate mechanisms from DNS caching. As explained in MDN's HTTP caching guide, HTTP caches store and reuse responses. Flushing DNS does not remove those responses, and purging CDN content does not clear A records from recursive resolvers.
When investigating HTTP caching, consider Cache-Control, Age, resource versions, and application identifiers together, rather than inferring the cache-hit location from one header. In the Cache-Control directive reference, no-cache means validation is required before reuse—not “do not store,” and certainly not “clear DNS.” Adding this request header also cannot force all managed caches to behave identically.
Use curl --resolve to test whether the new address is ready for traffic
When DNS results and page behavior disagree, you can direct the same HTTPS URL to the expected address without changing public DNS:
curl --noproxy '*' -sS -D - -o /dev/null --connect-timeout 5 --max-time 15 -w '\nremote_ip=%{remote_ip} http_code=%{http_code}\n' https://www.example.com/
curl --noproxy '*' -sS -D - -o /dev/null --connect-timeout 5 --max-time 15 --resolve www.example.com:443:203.0.113.10 -w '\nremote_ip=%{remote_ip} http_code=%{http_code}\n' https://www.example.com/
The second command overrides the name-to-address mapping for that request while preserving the hostname in the URL, HTTP Host, and TLS SNI. Accessing https://203.0.113.10/ directly may reach the wrong virtual host or trigger a certificate name mismatch, so it is not an equivalent comparison. Replace the example address with the expected service address that you are authorized and permitted to test.
Run both requests in the same terminal and on the same network, keeping the method, path, and request headers identical. --noproxy '*' excludes interference from environment-configured proxies, but use it only where network policy permits direct connections. If a proxy is required, account for the fact that it may perform resolution; do not interpret remote_ip directly as the target website's address.
If the ordinary request connects to the old address while the request forced to the new address succeeds, this establishes only that the new address works under those particular test conditions. You still need to investigate DNS or the client path. If the new address produces a certificate error, connection failure, or incorrect application page, finish configuring the new service first; switching public DNS to it is not a fix. HTTP 200 does not automatically mean the application is correct either—check the expected content or application API results.
These commands do not automatically follow redirects, making it easier to inspect Location first. If the request redirects to another domain, check that domain separately. Even if you add -L, the first hop's --resolve does not automatically override every subsequent name. If you are comparing a direct origin address with a CDN address, the paths are inherently different. Interpret success or failure in light of origin access controls, origin authentication, and certificate settings, and do not broadly relax protections temporarily just for testing.
Fix the differences between query results instead of repeatedly flushing the same cache layer
Once you correlate the same name, type, and query time, the next step is usually clear. The table below compares combinations of observations; it does not impose identical failure rules on every DNS service.
Observations | Primary assessment | Next step |
|---|---|---|
The parent still delegates to the old NS servers, while records on the new platform are correct | The change is not yet in the actual delegation path | Check registrar NS settings, parent-zone answers, and any required glue |
Authoritative servers return different record sets | Authoritative publication, synchronization, or policies are inconsistent | Fix the affected replica or network-specific configuration, then recheck all relevant authoritative servers |
All authoritative answers are new, but the recursive answer is old with a decreasing TTL | An old positive cache entry has not yet expired | Observe according to the old TTL and actual resolver behavior; keep the old service available |
Authoritative servers have the record, but the recursive resolver still returns a negative answer | Negative caching may be involved | Compare status codes and SOA data, and check the negative-cache lifetime |
Authoritative answers are correct, but a validating recursive resolver returns SERVFAIL | A validation-chain or query-path failure may be involved | Check DNSSEC, delegation reachability, and transport |
DNS answers are all new, but the application still connects to the old endpoint or shows old content | A client-path, connection, or content-cache issue | Check browser DNS, connection reuse, proxies, and HTTP caching |
Keep fixes narrowly scoped. If only one authoritative replica is affected, fix that replica or its publication pipeline. If an internal recursive resolver has an abnormal cache entry, use its supported targeted cache-clearing function first rather than restarting the entire DNS service. For public resolvers you do not manage, do not assume there is a universal remote cache-flush command.
During an ongoing migration, keep the old and new services as compatible as possible throughout the transition. Do not retire the old endpoint based only on the new record's TTL. Also account for the old record's remaining lifetime, NS and glue caches, CNAME target caches, and connections that are still active. Where no single precise cutoff can be established, use request logs from the old endpoint together with actual resolution results, rather than promising “global activation a fixed number of minutes after the change.”
Rollback is also affected by caching. Changing a record back to the old value does not immediately return users who have already cached the new value. Before making a change, save the original records, TTLs, proxy status, and network-specific conditions. Restore these related settings during rollback, and ensure that neither endpoint serves incorrect or incompatible application responses while old and new cache entries coexist.
How to determine when DNS troubleshooting is complete
Acceptance checks should follow the objects actually changed, rather than expanding indefinitely into unrelated tests. If you changed only A, confirm that the relevant authoritative servers return the same A record set, that the actual recursive resolvers update as expected, and that AAAA will not send traffic to another environment. If you changed NS, you must also verify parent-zone delegation, old and new authoritative servers, and any required glue.
If the change was made to connect to Alibaba Cloud CDN, follow DNS verification with domain and cache activation checks, validating DNS routing separately from actual content delivery. An updated CNAME answers only the DNS-layer question; it does not by itself prove that HTTPS, origin fetching, and caching are all configured as the application requires.
Use the following sequence for a minimal final check:
Query the parent zone and relevant authoritative servers again. Confirm that the expected delegation is in use and that no target names or record types have been missed.
Query the recursive resolvers that previously returned old values. Record the final data, status codes, and TTLs. Keep timeouts and failures separate; do not count them as successful updates.
Make a new request through the actual application path. Verify the destination connection, TLS certificate, and application content—not just DNS or HTTP status codes.
Restore normal settings for any caches, proxies, or clients changed during testing. Confirm that no temporary hosts entries or forced address mappings remain.
Before retiring the old endpoint, inspect remaining requests and distinguish actual user connections from monitoring probes and other sources, then decide whether to stop the compatibility service.
Whether a DNS change has taken effect ultimately depends on four things together: correct parent-zone delegation, correct authoritative answers, correct results from the actual resolver, and the application using the expected path. Fix configuration when authoritative answers are wrong, analyze caching when recursive answers are old, and check connections and content when DNS is already updated. Identifying the differences between these results gives waiting a clear basis and keeps fixes focused on the right layer.
- DNS changes not taking effect
- authoritative DNS queries
- DNS cache
- DNS troubleshooting with dig
- DNS TTL
- DNS negative caching
- NS delegation
- CNAME caching