Free DNS Lookup Online

DNS Lookup: Query A, AAAA, MX, TXT, NS, CNAME, SOA, and CAA Records for Any Domain

A DNS lookup asks the domain name system what a given domain actually points to — which IP addresses answer for it, which mail servers accept email for it, which name servers are authoritative for it, and what arbitrary text values it publishes for verification and policy purposes. This tool takes a domain name and a record type, sends that query out to the domain name system on your behalf, and returns whatever records come back, formatted so you can read them at a glance instead of parsing raw resolver output. Because the query has to reach the domain name system itself rather than something your device already has cached, the lookup runs on the server: you type a domain, the request goes to FreeConvertingTools, and the server performs the actual resolution before handing the records back to your browser.

That distinction matters because DNS is the layer almost everything else on the internet depends on silently. A misconfigured MX record means email bounces. A CNAME that still points at an old host means a migration isn't finished. A missing or wrong CAA record can block a certificate authority from issuing a certificate you expect it to be able to issue. None of that is visible from a browser tab showing a website — you have to ask the domain name system directly, which is exactly what this DNS lookup tool exists to do quickly, for any of eight record types, without installing a command-line utility or remembering its flags.

How to Run a DNS Lookup with This Tool

1. Type the domain you want to inspect into the input field — a bare domain like example.com works directly; if you paste a full URL, the leading https:// and any path after the domain are stripped automatically before the query is sent.
2. Pick a record type from the dropdown: A, AAAA, MX, TXT, NS, CNAME, SOA, and CAA are each queryable on their own, or choose ALL to query every supported type in one pass.
3. Press Lookup (or hit Enter) — the domain and record type are sent to the server, which queries the domain name system and returns the results, typically within a couple of seconds.
4. Each record type you queried appears as its own card, showing every record returned for that type along with a count, so an MX lookup with three mail servers listed shows all three, ranked in the order the domain name system returned them.
5. If a record type comes back empty, the card explains why: a domain that genuinely has no records of that kind reads "No records of this type," while a domain that doesn't resolve at all reads "Domain not found" — two very different situations that look identical if you're only staring at an empty list.
6. Re-run the lookup with a different record type as needed — each query is independent, so switching from A to MX to TXT is just a matter of changing the dropdown and clicking Lookup again.

Why People Need to Look Up DNS Records

• Verifying a migration actually took effect. After pointing a domain at a new host, the A or AAAA record is the first thing to check — DNS lookup shows exactly what address the domain resolves to right now, which is the only reliable way to confirm the change propagated rather than assuming it did because the new server is configured correctly.
• Diagnosing email that isn't arriving. An MX record lookup reveals which mail servers are supposed to be accepting mail for a domain, in priority order — if the list is empty, wrong, or pointing at a decommissioned provider, that alone explains why messages are bouncing or silently vanishing.
• Confirming domain ownership or service verification. Google Search Console, many SaaS platforms, and SPF/DKIM email authentication all rely on a specific TXT record being present at the domain — looking it up directly confirms the value actually published matches what the verifying service expects, rather than trusting that a control panel saved it correctly.
• Checking where authority for a domain actually sits. An NS lookup lists the name servers a domain is delegated to, which matters most right after switching registrars or DNS providers — a stale NS record still pointing at the old provider means changes made in the new one won't take effect anywhere.
• Tracing a CNAME to its real destination. A subdomain often isn't an address in its own right but an alias pointing at another hostname — a CNAME lookup shows that target directly, which is useful for confirming a CDN, a hosted app platform, or a third-party service is wired up the way its setup instructions describe.
• Reading zone metadata and certificate restrictions. SOA records carry the serial number and refresh timers a domain's zone file uses, useful when comparing whether two name servers have actually synced, while CAA records restrict which certificate authorities are permitted to issue for the domain at all — both are easy to overlook until something depending on them breaks.

What Each Record Type Actually Returns

Type	What it returns	Typical use
A	One or more IPv4 addresses the domain resolves to	Confirming which server currently answers for the domain
AAAA	One or more IPv6 addresses the domain resolves to	Confirming IPv6 reachability alongside or instead of IPv4
MX	Mail exchange hostnames with a priority number for each	Diagnosing where inbound email for the domain is routed
TXT	Arbitrary text strings published at the domain	Domain verification tokens, SPF policy, DKIM keys, and similar
NS	The authoritative name servers the domain is delegated to	Confirming DNS hosting/registrar delegation is correct
CNAME	The single hostname a name is aliased to	Tracing a subdomain to its real target (CDN, SaaS host, etc.)
SOA	Zone metadata: primary name server, serial, refresh/retry/expire timers	Comparing zone state and sync timing between name servers
CAA	Which certificate authorities are authorized to issue for the domain	Explaining why a specific CA refuses or accepts an issuance request

The tool queries these through the same DNS resolver machinery any server uses (Node's built-in resolver functions, each bound to a short timeout so one slow record type can't stall the rest), and it bounds the number of records returned per type so a domain with an unusually long TXT or NS list still comes back quickly. Because the domain you enter is sent to the server to run this query, the server is the one actually talking to the domain name system on your behalf — nothing about the domain or the returned records is retained afterward; the response is generated and sent back, and that's the end of it.

A Note on What This Tool Does and Doesn't Touch

It's worth being precise about the boundary here: a DNS lookup resolves records — it asks "what does this domain claim, and what values does the domain name system hand back" — but it never connects to any of the addresses those records name. Looking up an A record that happens to point at a private or internal-looking address doesn't mean this tool reaches out to that address; it simply reports what the domain name system returned, informationally, the same as any DNS resolver would. That's different from some of the other tools in this network category — the SSL certificate checker, for instance, actually opens a connection to a host you give it, and for that class of tool this site enforces a public-address check that refuses to connect to a private, loopback, internal, or link-local target before any connection is attempted. DNS lookup doesn't need that particular guard because it never takes the second step of connecting anywhere; it stops at asking the question and reporting the answer.

Common DNS Lookup Pitfalls

The most common confusion is treating a fresh DNS change as instant. Records carry a time-to-live value that tells resolvers how long they're allowed to cache an answer before asking again, so a change made minutes ago may not show up everywhere at once — a lookup run against the authoritative source reflects the current published value, but a browser or a different resolver elsewhere might still be serving a cached, older answer until its own cache expires. A second pitfall is misreading an empty result: "no records of this type" for, say, an AAAA query on a domain that only has IPv4 simply means the domain hasn't adopted IPv6, not that anything is broken. A third is forgetting that a CNAME can't coexist with most other record types at the exact same name — a hostname that's aliased via CNAME generally can't also carry its own independent TXT or MX records at that same label, which is a common source of "why won't my verification record save" confusion. Finally, remember that a subdomain is its own independent name in DNS: looking up example.com tells you nothing about what www.example.com or mail.example.com resolve to — each needs its own query.

Manual DNS Lookup vs. Using This Tool

• Command-line tools. dig and nslookup are the classic choices and give you full control over which resolver to query and how to format the output, but they require a terminal, correct syntax, and (on Windows especially) tools that aren't installed by default.
• Router or ISP-provided lookup pages. Some registrars and hosting control panels bundle a basic DNS checker, but they're usually limited to whatever record types that one interface decided to support, and often only show one record type at a time.
• Online "propagation checker" services. These typically query several resolvers around the world at once to show whether a change has spread globally — useful for propagation specifically, but overkill if you just need to see the current record from an authoritative source.
• Writing a small script. A short script using a language's built-in DNS resolution functions can automate repeated lookups, which makes sense if checking DNS records is one step in a larger monitoring or deployment pipeline rather than a one-off check.
• This tool's API. This same lookup also runs as a metered API endpoint, for anyone who needs DNS records inside a script, a monitoring job, or another application instead of a browser session — send a domain and record type and get the records back as JSON; the API documentation spells out the exact request shape and what it costs in credits.

Does this tool store the domains I look up?

No. The domain and record type you submit are used only to run the query and return the result; nothing about the request is kept afterward.

Why does an MX or TXT lookup sometimes return nothing even though the domain works fine?

A domain can serve a website perfectly well with no MX records at all if it doesn't handle its own email, and plenty of domains have no TXT records if they've never needed a verification token or an SPF policy. An empty result for one record type says nothing about whether the domain resolves for other purposes — check the specific record type relevant to whatever you're actually troubleshooting.

What's the difference between "domain not found" and "no records of this type"?

"Domain not found" (ENOTFOUND) means the domain itself doesn't exist in DNS at all — it isn't registered, or its delegation is broken. "No records of this type" (ENODATA) means the domain exists and resolves fine, it simply doesn't publish that particular record type — an entirely normal, healthy state for plenty of domains and record types.

Can I look up records for a subdomain instead of the root domain?

Yes — enter the subdomain exactly as you would the root domain, such as blog.example.com, and the lookup queries records for that specific name. A subdomain's records are entirely independent of the root domain's, so check the exact name you're interested in rather than assuming it inherits the root's records.

Related Network Tools

Once you've confirmed what a domain resolves to, a few related tools cover the rest of the picture. Run the WHOIS lookup to see who registered the domain and when it expires, use the SSL certificate checker to confirm the certificate presented by whatever host the A or AAAA record points at is valid and current, or check the website status checker and HTTP headers viewer to see how the site actually responds once your browser follows those DNS records to a live server.