All TLDs API | One Name Across All Extensions

Q: Can we list the registrations oldest first?

Yes. ordering=domain.whois.create_date puts the oldest registration first, and a - prefix puts the newest first.

Q: What does a malformed request return?

A 400 with code 10400 and a parameters entry for the field, such as an export value that is not a boolean.

Pass the Domain With Its Extension.

Send example.com, not example. The API takes the name from the domain you pass and returns a record for each extension that name is registered under.

GET https://api.deepinfo.com/v1/discovery/all-tlds Reference

Parameter	Type		Description
`domain`	string	Required	A registered domain, for example `example.com`.
`include_subdomains`	boolean	Optional	Include matching subdomains as well. Default `false`.
`page`	integer	Optional	Page number, from 1.
`page_size`	integer	Optional	Results per page.
`ordering`	string	Optional	Field to sort by. Prefix `-` for descending.
`export`	boolean	Optional	Return the result as an export instead of a page. Default `false`.
`export_format`	string	Optional	`json` or `csv`.
`export_scope`	string	Optional	How much of each record to include: `basic`, `default` or `extended`.

Request

curl "https://api.deepinfo.com/v1/discovery/all-tlds?domain=example.com&page_size=25" \
  -H "apikey: YOUR_API_KEY"

import requests

r = requests.get(
    "https://api.deepinfo.com/v1/discovery/all-tlds",
    params={"domain": "example.com", "page_size": 25},
    headers={"apikey": "YOUR_API_KEY"},
)
data = r.json()
print(data["result_count"])
for d in data["results"]:
    print(d["punycode"])

const r = await fetch(
  'https://api.deepinfo.com/v1/discovery/all-tlds?domain=example.com&page_size=25',
  { headers: { apikey: 'YOUR_API_KEY' } }
)
const { result_count, results } = await r.json()
console.log(result_count, results.map((d) => d.punycode))

Response

200 OK · application/json

{
  "page": 1,
  "page_size": 25,
  "result_count": 2,
  "results": [
    {
      "punycode": "example.net",
      "unicode": "example.net",
      "is_idn": false,
      "domain": {
        "extension": { "punycode": "net", "unicode": "net", "is_idn": false },
        "registered": true,
        "whois": { "registrar": "…", "create_date": "…" }
      }
    },
    {
      "punycode": "example.org",
      "unicode": "example.org",
      "is_idn": false,
      "domain": {
        "extension": { "punycode": "org", "unicode": "org", "is_idn": false },
        "registered": true,
        "whois": { "registrar": "…", "create_date": "…" }
      }
    }
  ]
}

The Questions One Name Raises.

Coverage

Which Extensions You Hold

All registrations of your brand name in one list, to check against the registrar and registrant you expect. An extension missing from the list has no registration the index knows of.

Brand impersonation

Exposure

Which Ones Someone Else Holds

Your exact name under extensions you never bought, with the DNS and certificate that show whether anything is live on them. Triage by registration age and registrar.

Phishing detection

Diligence

What an Acquisition Brings

A target’s name across all extensions: defensive registrations, gaps and names held by third parties, before the data room list is taken at its word.

M&A due diligence

Separate Yours From Everyone Else’s.

Each result carries its WHOIS, so triage starts with one comparison: which registrations use a registrar or registrant that is not yours.

For the ones that remain, the record already holds the next signals to read: creation date, mail servers, the certificate issuer and where the website redirects.

Domain Detail record

Python

import requests

r = requests.get(
    "https://api.deepinfo.com/v1/discovery/all-tlds",
    params={"domain": "example.com", "page_size": 100},
    headers={"apikey": "YOUR_API_KEY"},
)
OURS = "example registrar, llc"
for d in r.json()["results"]:
    whois = d["domain"].get("whois") or {}
    if whois.get("registrar") != OURS:
        print(d["punycode"], whois.get("registrar"), whois.get("create_date"))

Scope and Limits of the Sweep.

Exact name only	All TLDs matches the exact name. For typos and swapped letters, use `fuzzy` in Domain Search. Brand Risk Protection runs exact, fuzzy and confusable-character matching against your brands continuously.
New registrations	To catch new registrations of your name between sweeps, pair this call with the Daily Registered Domain Names feed.
Totals	`result_count` is the total number of matches across all pages. See pagination.
Rate limits	Plan-dependent. The default is one request per second per key and endpoint. See rate limits.

Other Ways to Find Related Names.

Discovery Domain Search Names a few characters away from yours, with the fuzzy operator. Read Discovery Associated Domain Finder Domains that share a registrant or infrastructure, whatever their name. Read Discovery Same-Time Registered Domains Domains a seed’s registrant registered within minutes of it. Read

Questions About All TLDs API

Is the domain we pass part of the result?

Yes. It comes back among the results, next to the same name under other extensions.

Can we list the registrations oldest first?

Yes. ordering=domain.whois.create_date puts the oldest registration first, and a - prefix puts the newest first.

How is the All TLDs API priced?

As part of an API services plan, priced by volume and frequency, separately from the platform. See Data & API pricing.

Can analysts run this sweep without writing code?

Yes. Deep Search & Insights runs All TLDs and the other pivots in the Deepinfo Platform. See Domain Search.

What does a malformed request return?

A 400 with code 10400 and a parameters entry for the field, such as an export value that is not a boolean.

Find Out Who Holds Your Name Elsewhere.

Send us the brand names you care about. We set up access and run a sweep with your team on a short call.

Talk to us about access All API services

Platform

Solutions

Data & API

Resources

Company

Find Every Extension a Name Is Registered Under.