# DNS Trace and Delegation Checker

Resolve a name iteratively from the root servers, as a resolver does, and return every step: the server asked, its address, the time, the referral (zone, name servers, TTL, glue, DS present) or the answer, CNAME targets followed, and flags such as a lame or slow server. mode delegation tests a domain's delegation instead: parent name servers against the zone's own and the registry (RDAP), glue, lame delegation, SOA serial agreement, TCP and EDNS support and name server diversity; with newNameservers (up to 8) it asks the new servers directly and compares their records with the live ones before you switch. Public names only.

**Not for:** Reading records through a resolver you choose (use dns_lookup) or checking propagation (use dns_propagation).

- Tool id: `dns-trace`
- Category: dns
- Execution: network
- MCP tool `dns_trace` at https://lookupowl.com/mcp
- REST `GET https://lookupowl.com/api/v1/tools/dns-trace` (or POST a JSON body)
- OpenAPI: https://lookupowl.com/api/openapi.json

## Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `name` | string | yes |  | A domain name, or any name under it, such as example.com. For mode delegation it is the domain whose delegation is tested. min length 1, max length 253 |
| `type` | "A" \| "AAAA" \| "MX" \| "TXT" \| "NS" \| "SOA" \| "CNAME" \| "CAA" \| "DS" \| "DNSKEY" \| "PTR" \| "SRV" \| "HTTPS" | no | `"A"` | Record type to resolve (mode trace only). |
| `family` | "any" \| "ipv4" \| "ipv6" | no | `"any"` | Address family used to reach the servers. ipv6 shows whether the path works for people with no IPv4. |
| `qmin` | boolean | no | `false` | Hide the full name from upstream servers (QNAME minimisation, RFC 9156): ask each server only for the part it needs. |
| `mode` | "trace" \| "delegation" | no | `"trace"` | trace: the resolution path from the root. delegation: parent against child against RDAP, glue and every name server. |
| `newNameservers` | string[] | no |  | Before you switch (mode delegation): up to 8 host names or public IP addresses of new name servers. They are asked directly for the zone's records and compared with what resolvers see now. Nothing changes. max 8 items |

## Output

Results are wrapped in an envelope: `tool`, `version`, `requestId`, `data`, `summary`, `meta` (cache status, timing), `permalink`. `data` has these fields:

| Field | Type | Description |
|---|---|---|
| `name` | string |  |
| `mode` | "trace" \| "delegation" |  |
| `type` | string |  |
| `family` | "any" \| "ipv4" \| "ipv6" |  |
| `qmin` | boolean |  |
| `trace` | object |  |
| `delegation` | object |  |
| `summary` | string |  |

## Examples

### Trace lookupowl.com from the root

```json
{"name":"lookupowl.com","type":"A","family":"any","qmin":false,"mode":"trace"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/dns-trace?family=any&mode=trace&name=lookupowl.com&qmin=false&type=A'
```

Web page: https://lookupowl.com/dns-trace?q=lookupowl.com

### Trace www.cloudflare.com

```json
{"name":"www.cloudflare.com","type":"A","family":"any","qmin":false,"mode":"trace"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/dns-trace?family=any&mode=trace&name=www.cloudflare.com&qmin=false&type=A'
```

Web page: https://lookupowl.com/dns-trace?q=www.cloudflare.com

### Delegation of cloudflare.com (glue required)

```json
{"name":"cloudflare.com","type":"A","family":"any","qmin":false,"mode":"delegation"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/dns-trace?family=any&mode=delegation&name=cloudflare.com&qmin=false&type=A'
```

Web page: https://lookupowl.com/delegation-check?q=cloudflare.com

### Delegation of lookupowl.com

```json
{"name":"lookupowl.com","type":"A","family":"any","qmin":false,"mode":"delegation"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/dns-trace?family=any&mode=delegation&name=lookupowl.com&qmin=false&type=A'
```

Web page: https://lookupowl.com/delegation-check?q=lookupowl.com

## Web pages

- https://lookupowl.com/dns-trace
- https://lookupowl.com/delegation-check

## Limits and caching

- Cost: from 1 unit up, depending on the input (a registry lookup counts every upstream request); 1 unit for a cached result. Budgets are per network and published in the `RateLimit` response headers.
- Cache: results are kept for 120 s. Add `fresh=true` (MCP argument or query parameter) to look again; it costs 3 units per unit and is limited to 10 per hour.
- Timeout: 20 s.

## Related tools

- [DNS Lookup](https://lookupowl.com/tools/dns-lookup.md): Look up A, AAAA, MX, NS, TXT, CNAME, SOA, CAA, DS and DNSKEY records from a public resolver or the authoritative nameserver.
- [DNS Propagation Checker](https://lookupowl.com/tools/dns-propagation.md): Check whether a DNS change has reached public resolvers around the world and which caches are still stale.
- [DNSSEC Checker and Chain Visualizer](https://lookupowl.com/tools/dnssec-check.md): Check the DNSSEC chain of trust from the root to a name, link by link, and see which link is broken and how to fix it.
- [DNS Health Checker](https://lookupowl.com/tools/dns-health.md): A full DNS health report for a domain: delegation, name servers, SOA, DNSSEC, mail records, IPv6 and security, with the fix for each problem.
- [WHOIS Lookup](https://lookupowl.com/tools/whois-lookup.md): Registrar, creation and expiry dates, status codes, nameservers and DNSSEC for any domain, from RDAP with WHOIS fallback.
- [Reverse DNS Lookup](https://lookupowl.com/tools/reverse-dns.md): Find the host name (PTR record) of an IPv4 or IPv6 address and check that it resolves back to the same address.

## Guide: DNS trace

Follow a lookup from the root servers down to the answer, one referral at a time, and see why a change is not live yet.

### How a DNS trace works

No server knows every domain. Instead the system is a chain of pointers. A resolver with nothing in its memory asks one of the 13 root server addresses, which does not know your domain but knows who runs the top-level domain, such as `com`. That server does not know your domain either, but it knows which name servers your domain is delegated to. Those name servers finally give the answer. Each pointer is called a referral.

This page does the same walk, from our server, and shows every step: the server asked, its address, how long it took, what it sent back and for how long that may be kept. It is the same thing `dig +trace` prints, laid out so you can read it without knowing the output format.

1. **Enter a name**: A domain or any name under it, such as `www.example.com`. Record type A is the default; open More options for MX, TXT, NS, CAA and others.
2. **Read the path**: The first steps are referrals. The last step is the answer, marked authoritative when it comes from a server that holds the zone.
3. **Check the timing and the TTL**: The bars share one scale, so the slowest step is the longest. The time to live on the last step tells you how long other resolvers may keep the answer.

### What each step tells you

- **Referral to a zone.** The server does not hold the answer but names the servers that do. The line under it says how many name servers it listed, whether it sent glue (their addresses, so the trace can continue) and how long a resolver may keep the referral.
- **DS present or No DS.** A referral carries a DS record when the child zone is signed with DNSSEC. This page does not validate anything. Use the [DNSSEC check](https://lookupowl.com/dnssec-check) to see whether the chain of trust holds.
- **Answer, authoritative.** The records you asked for, from a server that holds the zone itself, with the TTL of each.
- **Alias (CNAME).** The name points to another name. The target is traced as its own block, up to four aliases deep.
- **No record of this type, or Name does not exist.** The name is real but has no record of the type you asked for, or it does not exist at all. The SOA record sets how long a resolver remembers that no.

> **Where the times come from** Every time is the round trip from LookupOwl's server to that server, not from your computer or your resolver. They are good for comparing steps with each other and for spotting a slow server. They do not tell you how fast your own lookups are.

The first two steps are referrals for the root and the top-level domain. They change rarely, so they are kept for about two days. Your own resolver almost never repeats them, which is why the page says so under the path.

### Why a change is not live yet

After you change a record, the servers that hold the zone have the new value at once. Everyone else is holding a copy that stays valid until its TTL runs out. The TTL of the answer on the last step is therefore the number that decides how long a change takes to reach people: at 300 seconds, within about five minutes. At 86400 seconds, up to a day.

| What you see | What it usually means | What to do |
|---|---|---|
| The trace shows the new value | The zone is updated. Other resolvers are waiting for their copy to expire. | Wait for the TTL, or check [DNS propagation](https://lookupowl.com/dns-propagation-checker) to see who has caught up. |
| The trace shows the old value | The change is not published at the servers that hold the zone. | Check the DNS provider. Waiting will not help. |
| Two traces give different answers | The name is load balanced, or the servers of the zone disagree. | The page notes it. The delegation check shows whether the servers are in sync. |

### When the trace shows a problem

A trace is also the quickest way to find where a lookup breaks. A server that refuses to answer for its zone, one that never answers, a slow step and a delegation that loops are each marked on the step where they happen, and the answer at the top says what that means.

- **A server refuses or is not authoritative.** It is listed for the domain but does not hold it. The trace carries on with another server, and the [delegation checker](https://lookupowl.com/delegation-check) lists every server with its result.
- **No answer in time.** We wait about two seconds for each server, then ask the next. One silent server is common. If every server of a zone is silent, the trace stops there and says so.
- **A loop.** Two zones send the lookup back and forth. The trace stops and names the fix: correct the name server list at one of the registrars.
- **IPv6 only.** Choose IPv6 only in More options to see whether the path works for someone with no IPv4 at all. If our own server cannot reach IPv6 at that moment, the page says it could not test, which is on our side.

### Options and limits

QNAME minimisation hides the full name from the servers high up in the chain. With it on, the root server is asked only for `com`, the top-level server only for `example.com`, and only the last step sees the whole name. Many resolvers do this today, and each step of the trace shows the name that was really sent.

Only public names are traced, and only public server addresses are asked. A trace asks about ten servers and takes a few seconds. The same trace is available to AI assistants as the `dns_trace` tool through the LookupOwl MCP server, with the text version of the path in the result.

### Frequently asked questions

**Why trace instead of a normal lookup?**

A normal lookup asks a resolver, which may answer from its memory. A trace asks the servers that hold the data, one referral at a time. It shows which servers answered, in what order, and where a lookup breaks, which a plain lookup cannot.

**Is this the same as dig +trace?**

It follows the same path from the root servers. The trace is run from our server, so times and the first answer you see may differ from running it at home. The result includes a text version in dig +trace layout that you can copy into a ticket.

**What does QNAME minimisation do?**

It sends each server only the part of the name it needs, as many real resolvers do. The root server hears about `com`, not about your full name. It is off by default; when it is on, each step shows the name that was sent.

**Why do the first two steps say they are usually skipped?**

The referrals from the root and from the top-level domain stay valid for about two days. A resolver that has seen any name in that top-level domain recently already has them, so it starts further down. We always ask from the top so that you can see the whole path.

**Does the trace check DNSSEC?**

No. It only shows whether each referral carries a DS record, which means the next zone is signed. To check that the signatures and keys hold up, use the DNSSEC check.

**Why did two traces of the same name give different answers?**

Some names are load balanced on purpose: the servers give a different set of addresses each time. The page notes it when it sees that. If the servers of a zone disagree about a record that should be the same everywhere, the delegation check shows it.
