GET /check

Check Domain Availability

Learn more: Domain Availability API — marketing overview, live demo, and use cases.

Check if a domain name is available for registration across multiple TLDs.

Endpoint

GET https://api.robotdomainsearch.com/check

Parameters

Parameter	Type	Required	Description
`name`	string	Yes	Domain name to check (without TLD)
`tld`	string	No	TLD(s) to check. Supports comma-separated values (e.g., `com,net,io`). Max 20.
`category`	string	No	Check all TLDs in a category (e.g., `technology`). Use `GET /tlds` to list categories.

Note: If neither tld nor category is specified, checks the Top 20 TLDs.

Request

Check a single TLD:

curl "https://api.robotdomainsearch.com/check?name=mycoolstartup&tld=com"

Check multiple TLDs:

curl "https://api.robotdomainsearch.com/check?name=mycoolstartup&tld=com,net,io,ai"

Check by category:

curl "https://api.robotdomainsearch.com/check?name=mycoolstartup&category=technology"

Check Top 20 (default):

curl "https://api.robotdomainsearch.com/check?name=mycoolstartup"

Single TLD Response

When checking exactly one TLD, the API returns a flat response:

{
  "name": "mycoolstartup",
  "results": [
    {
      "domain": "mycoolstartup.com",
      "tld": "com",
      "available": true,
      "status": ["undelegated", "inactive"],
      "premium": false,
      "source": "rdap",
      "checkedAt": "2025-02-10T12:00:00Z",
      "responseMs": 180
    }
  ],
  "totalMs": 180,
  "timestamp": "2025-02-10T12:00:00Z"
}

Bulk Response

When checking 2 or more TLDs, the API returns a bulk response with summary counts:

{
  "name": "startup",
  "results": [
    {
      "domain": "startup.com",
      "tld": "com",
      "available": false,
      "status": ["active"],
      "premium": false,
      "source": "dns",
      "checkedAt": "2025-02-10T12:00:00Z",
      "responseMs": 45
    },
    {
      "domain": "startup.net",
      "tld": "net",
      "available": true,
      "status": ["undelegated", "inactive"],
      "premium": false,
      "source": "rdap",
      "checkedAt": "2025-02-10T12:00:00Z",
      "responseMs": 180
    }
  ],
  "checked": 4,
  "available": 2,
  "unavailable": 1,
  "errors": 1,
  "totalMs": 320,
  "timestamp": "2025-02-10T12:00:00Z"
}

Response Fields

Top-Level Fields

Field	Type	Description
`name`	string	The domain name that was checked (without TLD)
`results`	array	List of domain check results
`totalMs`	number	Total time to check all domains in milliseconds
`timestamp`	string	ISO 8601 timestamp when the check was performed

Bulk Response Fields

These fields are included when checking 2 or more TLDs:

Field	Type	Description
`checked`	number	Total number of TLDs checked
`available`	number	Count of available domains
`unavailable`	number	Count of unavailable domains
`errors`	number	Count of TLDs that had check errors

Result Fields

Field	Type	Description
`domain`	string	Full domain name checked
`tld`	string	Top-level domain
`available`	boolean	`true` if available for registration
`status`	array	Array of status strings (see below)
`premium`	boolean	`true` if this is a premium-priced domain
`source`	string	How availability was determined (see below)
`checkedAt`	string	ISO 8601 timestamp of this specific check
`responseMs`	number	Response time for this check in milliseconds
`error`	string	Error message if the check failed (omitted on success)

Status Values

Status	Description
`unknown`	Could not determine status
`undelegated`	No DNS records (domain not set up)
`inactive`	Available for registration
`active`	Registered/taken
`premium`	Premium pricing applies

Source Values

Source	Description
`dns`	Determined via DNS nameserver lookup
`rdap`	Confirmed via RDAP query
`dns+cache`	Cached DNS result
`rdap+cache`	Cached RDAP result

Errors

Code	Error	Description
400	`missing_parameter`	The `name` parameter is required
400	`invalid_name`	Name must be 1-63 characters, alphanumeric with hyphens
400	`unsupported_tld`	Specified TLD is not supported
400	`invalid_category`	Unknown category. Use `GET /tlds` for available categories.
400	`too_many_tlds`	Maximum 20 TLDs per request
429	`rate_limit_exceeded`	Too many requests

Code Examples

curl

# Check Top 20 TLDs (default)
curl "https://api.robotdomainsearch.com/check?name=mycoolstartup"

# Check specific TLDs
curl "https://api.robotdomainsearch.com/check?name=mycoolstartup&tld=com,net,io,ai"

# Check by category
curl "https://api.robotdomainsearch.com/check?name=mycoolstartup&category=technology"

Python

import requests

# Check multiple TLDs
response = requests.get(
    "https://api.robotdomainsearch.com/check",
    params={"name": "mycoolstartup", "tld": "com,net,io,ai"}
)
data = response.json()

print(f"Checked: {data['name']}")
print(f"Available: {data.get('available', 'N/A')}/{data.get('checked', len(data['results']))}")
print(f"Total time: {data['totalMs']}ms")

for result in data["results"]:
    status = "✓" if result["available"] else "✗"
    premium = " [PREMIUM]" if result["premium"] else ""
    print(f"{status} {result['domain']}{premium} ({result['source']}, {result['responseMs']}ms)")

JavaScript

const response = await fetch(
  "https://api.robotdomainsearch.com/check?name=mycoolstartup&tld=com,net,io,ai"
);
const data = await response.json();

console.log(`Checked: ${data.name}`);
console.log(`Available: ${data.available ?? "N/A"}/${data.checked ?? data.results.length}`);
console.log(`Total time: ${data.totalMs}ms`);

data.results.forEach(result => {
  const status = result.available ? "✓" : "✗";
  const premium = result.premium ? " [PREMIUM]" : "";
  console.log(`${status} ${result.domain}${premium} (${result.source}, ${result.responseMs}ms)`);
});

Go

resp, err := http.Get("https://api.robotdomainsearch.com/check?name=mycoolstartup&tld=com,net,io,ai")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var data struct {
    Name        string `json:"name"`
    Results     []struct {
        Domain     string   `json:"domain"`
        TLD        string   `json:"tld"`
        Available  bool     `json:"available"`
        Status     []string `json:"status"`
        Premium    bool     `json:"premium"`
        Source     string   `json:"source"`
        ResponseMs int64    `json:"responseMs"`
    } `json:"results"`
    Checked     int    `json:"checked"`
    Available   int    `json:"available"`
    Unavailable int    `json:"unavailable"`
    Errors      int    `json:"errors"`
    TotalMs     int64  `json:"totalMs"`
    Timestamp   string `json:"timestamp"`
}

if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    log.Fatal(err)
}

fmt.Printf("Checked: %s (%d/%d available, %dms)\n",
    data.Name, data.Available, data.Checked, data.TotalMs)
for _, r := range data.Results {
    status := "✗"
    if r.Available {
        status = "✓"
    }
    premium := ""
    if r.Premium {
        premium = " [PREMIUM]"
    }
    fmt.Printf("%s %s%s (%s, %dms)\n", status, r.Domain, premium, r.Source, r.ResponseMs)
}

Notes

Domain names are automatically normalized to lowercase
Special characters and spaces are rejected
Maximum name length is 63 characters (DNS limit)
Maximum 20 TLDs per request (via tld or category)
Results are cached for improved performance
Premium domain detection is based on registry notices
Duplicate TLDs in comma-separated lists are automatically removed

📄 Raw markdown: /docs/api/availability.md