API Documentation

Domain Availability API

Check domain availability programmatically. Designed for AI agents with simple, deterministic responses (currently powered by Name.com).

Why AgentDomainService Exists

The Problem: When AI agents try to help users check domain availability, they hit a wall. Traditional domain registrars like GoDaddy, Namecheap, and Google Domains block automated access with CAPTCHAs, Web Application Firewalls (WAFs), and JavaScript-heavy interfaces that AI cannot navigate.

The Insight: While AI agents struggle with complex web interfaces, they excel at one thing: fetching and parsing simple web pages. A deterministic URL that returns structured data is trivial for any AI to use.

The Solution: AgentDomainService provides deterministic URLs for domain availability checks. No CAPTCHAs, no JavaScript required, no authentication needed. Just fetch agentdomainservice.com/lookup/example.com and get an instant answer with pricing data from Name.com's registrar API.

Built for AI Agents: Every page includes embedded JSON in a <script type="application/json"> tag, making it easy for agents to extract structured data. Responses are server-side rendered (SSR), so even the simplest HTTP GET request returns complete information.

Quick Start

Check if a domain is available with a single GET request:

curl "https://agentdomainservice.com/lookup/example.com"

Each page contains embedded JSON in a script tag for easy parsing:

<script type="application/json" id="ads-result">
  {"domain": "example.com", "available": true, ...}
</script>

Endpoints

GET

/lookup/{domain}

Check a single domain - HTML page with embedded JSON (recommended)

GET

/explore/{name}

Check a name across 8 TLDs - HTML page with embedded JSON (recommended)

GET

/ideas

Browse curated domain ideas by category

Parameters

Parameter	Type	Description
`domain`	path	The domain to check (e.g., example.com, my-startup.io)
`format`	query	Response format: `json` or `txt`. Omit for HTML.

JSON Response

Use ?format=json for structured data:

{
  "domain": "example.com",
  "available": true,
  "status": "available",
  "checked_at": "2024-01-15T10:30:00.000Z",
  "expires_at": null,
  "source": "namecom",
  "purchase_price": 12.99,
  "renewal_price": 12.99,
  "premium": false,
  "cache": {
    "hit": false,
    "ttl_seconds": 120,
    "stale": false
  }
}

Response Fields

Field	Type	Description
`domain`	string	The normalized domain name
`available`	boolean	`true` if domain can be registered
`status`	string	available registered unknown
`checked_at`	string	ISO 8601 timestamp of the check
`purchase_price`	number \| null	Registration price in USD
`renewal_price`	number \| null	Annual renewal price in USD
`premium`	boolean	`true` if premium pricing applies
`cache.hit`	boolean	Whether result was served from cache
`cache.ttl_seconds`	number	Cache time-to-live in seconds

Text Response

Use ?format=txt for simple key-value pairs:

domain=example.com
available=true
status=available
checked_at=2024-01-15T10:30:00.000Z
expires_at=
source=namecom
purchase_price=12.99
renewal_price=12.99
premium=false
cache_hit=false
ttl_seconds=120
cache_stale=false

Examples

Check a .com domain

curl "https://agentdomainservice.com/lookup/myawesomestartup.com"

Check a .io domain

curl "https://agentdomainservice.com/lookup/coolproject.io"

Explore a name across TLDs

curl "https://agentdomainservice.com/explore/coolstartup"

Get suggestions with context

curl "https://agentdomainservice.com/lookup/stripe.com?context=payment+processing+api"

Python example (extract embedded JSON)

import requests
from bs4 import BeautifulSoup
import json

html = requests.get(
    "https://agentdomainservice.com/lookup/example.com"
).text

soup = BeautifulSoup(html, 'html.parser')
script = soup.find('script', {'id': 'ads-result'})
data = json.loads(script.string)

if data["available"]:
    print(f"{data['domain']} is available for ${data['purchase_price']}")
else:
    print(f"{data['domain']} is already registered")

JavaScript example (extract embedded JSON)

// In a browser or with a DOM parser
const response = await fetch(
  "https://agentdomainservice.com/lookup/example.com"
);
const html = await response.text();

// Parse and extract the embedded JSON
const parser = new DOMParser();
const doc = parser.parseFromString(html, 'text/html');
const script = doc.getElementById('ads-result');
const data = JSON.parse(script.textContent);

console.log(data.available ? 'Available!' : 'Taken');

Tips for AI Agents

Use /api/v1/lookup/ for JSON responses that are easy to parse programmatically
Check the available boolean — true means you can register it
Check the premium flag — premium domains have higher prices
Use HTTP cache headers — responses include Cache-Control with a short TTL (varies by status)
No authentication required — just make the request

Use Cases

AI Assistants

ChatGPT, Claude, Gemini, and Perplexity can help users brainstorm and verify domain names by fetching real-time availability data.

Startup Name Generators

Build tools that generate creative names and instantly verify which .com, .io, and .ai domains are available.

Brand Protection

Monitor domain availability across multiple TLDs to protect your brand from typosquatting and cybersquatting.

Developer Automation

Integrate domain checks into CI/CD pipelines, Slack bots, or custom tools without dealing with CAPTCHA-protected registrar sites.

Rate Limits

No authentication is required. We ask for reasonable use. If an upstream provider rate limits a request, the API may return status=unknown with a short cache TTL.

For AI Agents

A machine-readable summary of this API is available at:

https://agentdomainservice.com/llms.txt