# Domain Availability API: Is a Domain Taken? (`ucchiii/domain-availability-api`) Actor

Domain availability API: send domain names, get one short row per name with available true/false, status and TLD. Built for calls from code and automations: up to 1,000 names per run, fast defaults, details on request. Unknown and invalid names are free. Empty input = free demo.

- **URL**: https://apify.com/ucchiii/domain-availability-api.md
- **Developed by:** [Actor Factory](https://apify.com/ucchiii) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 checked domains

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Domain Availability API: send domain names from your code, get back one short JSON row per name — is it taken (`available: false`), free (`available: true`) or undecided (`null`).**

> **Acceptable use:** Do not use this Actor to register domains that contain someone else's trademark or brand (cybersquatting) or for impersonation. Follow the terms of use of the registries' RDAP services.

**For developers and automation builders** who need a yes/no domain check inside an app, a script, a spreadsheet job or a no-code flow (Zapier, Make, n8n): one HTTP call in, a small JSON array out. No API keys of your own, no scraping, no proxies — the answer comes from the registries' own RDAP services and DNS.

- **Short rows by default**: `domain`, `available`, `status`, `tld`, `checkedAt`, `error`. Registrar and dates only when you ask (`details: true`).
- **Up to 1,000 names per run** (call it again for more), cleaned for you: lowercased, URLs cut to the host name, internationalized names converted to punycode, duplicates removed.
- **Pay only for answers**: $0.0015 per name that comes back `registered` or `available`. `unknown` and `invalid` rows are free, and there is no per-run fee, so many tiny calls cost the same as one big one.

### Call it from code

The quickest way is the synchronous endpoint `run-sync-get-dataset-items`: it starts a run, waits for it and returns the rows as the HTTP response. Replace `<YOUR_APIFY_TOKEN>` with your token from Apify Console → Settings → API & Integrations.

#### curl

```bash
curl -s -X POST "https://api.apify.com/v2/acts/ucchiii~domain-availability-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["apify.com", "my-new-startup-name-2026.com", "python.org"]}'
```

#### Python

```python
import requests

resp = requests.post(
    "https://api.apify.com/v2/acts/ucchiii~domain-availability-api/run-sync-get-dataset-items",
    headers={"Authorization": "Bearer <YOUR_APIFY_TOKEN>"},
    json={"domains": ["apify.com", "my-new-startup-name-2026.com", "python.org"]},
    timeout=300,
)
for row in resp.json():
    print(row["domain"], row["available"], row["status"], row["error"])
```

#### JavaScript (Node.js 18+)

```js
const res = await fetch(
  "https://api.apify.com/v2/acts/ucchiii~domain-availability-api/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: { Authorization: "Bearer <YOUR_APIFY_TOKEN>", "Content-Type": "application/json" },
    body: JSON.stringify({ domains: ["apify.com", "my-new-startup-name-2026.com", "python.org"] }),
  },
);
const rows = await res.json();
const free = rows.filter((r) => r.available === true).map((r) => r.domain);
console.log(free);
```

Keep your token on the server side; do not ship it in a public web page.

#### What comes back

```json
[
  {"domain": "python.org", "available": false, "status": "registered", "tld": "org", "checkedAt": "2026-11-13T02:17:04Z", "error": null},
  {"domain": "this-domain-should-not-exist-9f3k2.org", "available": true, "status": "available", "tld": "org", "checkedAt": "2026-11-13T02:17:04Z", "error": null},
  {"domain": "apify.com", "available": false, "status": "registered", "tld": "com", "checkedAt": "2026-11-13T02:17:04Z", "error": null}
]
```

*(Real rows from a run on Apify on 2026-11-13.)* Rows can come back in a different order than you sent them — match them by `domain`.

**Large lists:** a synchronous call has a time limit on Apify's side, so for thousands of names start a normal run (`POST /v2/acts/ucchiii~domain-availability-api/runs`), wait for it to finish, then read `GET /v2/datasets/<defaultDatasetId>/items`. The `apify-client` packages for Python and JavaScript do this for you (`client.actor("ucchiii/domain-availability-api").call(run_input=...)`, then iterate the run's dataset).

**No-code tools:** use the Apify app or an HTTP request step with the same URL and JSON body; map `available` to your yes/no field.

### Use it from an AI agent (MCP)

Apify runs a hosted MCP server, so an AI assistant (Claude, Cursor, VS Code and other MCP clients) can call this Actor as a tool. Load only this Actor by naming it in the server URL:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=ucchiii/domain-availability-api" }
  }
}
```

On first use the client opens a browser so you can sign in to Apify (OAuth); a `Authorization: Bearer <APIFY_TOKEN>` header works too. Then ask in plain words, for example "Is mybrand.io free? Check mybrand.com and mybrand.app as well." Each answered name is charged as in a normal run; `unknown` and `invalid` rows stay free. Setup details: [Apify MCP server docs](https://docs.apify.com/platform/integrations/mcp).

### Input

| field | type | default | what it does |
|---|---|---|---|
| `domains` | array of strings | — | Names to check, up to 1,000 per run (start more runs for bigger lists). A single string with names separated by new lines or commas is accepted too. Empty → free demo. |
| `details` | boolean | `false` | Add registrar, IANA ID, created / updated / expiry dates, days to expiry, registry status codes, nameservers and `method` to each row. Same price. |
| `concurrency` | integer | `10` | Names checked in parallel (1–25). |
| `timeoutSecs` | integer | `5` | Per-request timeout (1–60 s). Failed requests are retried up to 3 times. |

### Output

| field | meaning |
|---|---|
| `domain` | the name that was checked, normalized (for invalid input: the entry as you sent it) |
| `available` | `true` = looks free to register, `false` = taken, `null` = could not be decided or invalid input |
| `status` | `registered`, `available`, `unknown` or `invalid` |
| `tld` | the top-level domain, e.g. `com` (`null` for invalid input) |
| `checkedAt` | time of the check (UTC) |
| `error` | why a row is `unknown` or `invalid` (see below); `null` otherwise |

| status | how it is decided | charged |
|---|---|---|
| `registered` | the registry's RDAP has the record, or — for TLDs without RDAP and names the registry does not hold — DNS shows nameservers | yes |
| `available` | the registry's RDAP says "not found" **and** DNS shows no nameservers | yes |
| `unknown` | no answer could be trusted: the TLD has no RDAP and no nameservers, a timeout, a rate limit, a server error, or the shared `.com`/`.net` daily limit | no |
| `invalid` | not a valid domain name (e-mail addresses and IP addresses are refused too) | no |

Common `error` codes: `no_rdap_for_tld`, `rdap_timeout`, `rdap_http_<status>`, `dns_check_failed`, `uk_registry_not_queried_no_ns`, `verisign_daily_limit`, `verisign_refused`, `verisign_counter_unavailable`, `invalid_domain`.

The run's key-value store has a `SUMMARY` record with counts per status, the number of charged names and, if any, how many `.com`/`.net` names were skipped and why.

### This Actor or Domain Availability Checker?

Both come from the same developer and decide availability with the same rules (registry RDAP first, DNS before saying "available"). They differ in who they are shaped for:

| | **Domain Availability API** (this one) | [Domain Availability Checker](https://apify.com/ucchiii/domain-availability-checker) |
|---|---|---|
| Made for | calls from code and automations | people pasting a list in Apify Console |
| Row | 6 short fields; details on request | full row: registrar, dates, status codes, nameservers, method |
| Names per run | up to 1,000 | up to 1,000 |
| Defaults | 10 in parallel, 5 s timeout | 3 in parallel, 15 s timeout |
| Price | $0.0015 per answered name | $0.0005 per answered name |

**Pick this one** when a program reads the result and only needs "taken or not". **Pick the Checker** when you want to read a table yourself with the registrar and expiry dates in every row.

### The shared `.com` / `.net` daily limit

To stay polite to Verisign, the registry for `.com` and `.net`, our Actors share one daily budget of lookups to its RDAP service. This Actor uses the same budget as Domain Availability Checker, so together they never send more than that budget. What it means for you:

- When the day's budget is used up, `.com`/`.net` names come back `unknown` with `error: "verisign_daily_limit"` and are **not charged**. Other TLDs keep working. Try those names again later (the budget resets at 00:00 UTC).
- If Verisign refuses requests, `.com`/`.net` lookups stop for the rest of the day (`verisign_refused`, not charged).
- If the shared counter itself cannot be reached, this Actor does **not** guess: `.com`/`.net` names come back `unknown` with `verisign_counter_unavailable` (not charged) rather than going over the shared budget.

### Pricing

Pay per event: **$0.0015 per domain** with an answer (`registered` or `available`) — **$1.50 per 1,000 domains**. Store discounts apply automatically on higher Apify plans. `unknown`, `invalid` and the free demo are not charged, and there is no start fee.

On the Apify Free plan, the $5 of monthly platform credit covers about **3,300 answered domains** a month. Set a **maximum charge per run** to cap spend; the run stops cleanly when it is reached and the names not yet checked are counted in `SUMMARY` (`notChecked`).

**Free demo:** call it with an empty input (`{}`) and you get three sample rows marked `_demo: true`, not charged.

### Limits

- Up to 1,000 names per run after duplicates are removed (extra names are not checked and are counted in `SUMMARY` as `overLimit`).
- Polite pacing that input cannot change: at most 2 connections to one registry server at a time and at least 0.25 s between requests to it — about 4 lookups per second per registry. A list spread over several TLDs finishes faster than one that is all `.com`.
- **"Available" means the registry has no record and DNS has no nameservers** — not a promise you can buy it. Reserved, premium-priced or blocked names and registry rules can still stop a registration. Check with your registrar before you rely on it.
- TLDs without an RDAP service (many country codes, e.g. `.io`, `.de`) are decided from DNS only: nameservers → `registered`; no nameservers → `unknown`, because DNS alone cannot prove a name is free.
- `.uk` names are never looked up in the `.uk` registry's RDAP (its terms forbid commercial copying); they are decided from DNS only, as above.
- Subdomains are checked at the registered domain (`www.example.com` → `example.com`). Names under multi-part suffixes such as `co.uk` should be given as the registered domain itself.
- Reusing registry data is subject to each registry's terms; that is your responsibility.

### Privacy

Registrant, administrative, technical and billing contacts are never read or returned — no names, e-mails, phone numbers or addresses. With `details: true` you get only the registrar (a company), dates and status codes, and every row carries `registrantRedacted: true`.

### FAQ

**How fast is one call?** A few names usually come back within seconds; most of the time is the registries' own response time. Each registry is paced at about 4 lookups per second, so a list of 1,000 `.com` names takes several minutes — use a normal run for lists like that.

**Is this WHOIS?** It uses RDAP, the protocol ICANN requires registries to run as the successor of WHOIS, plus a DNS check. It does not connect to port-43 WHOIS servers.

**Why is a name `unknown`?** See `error`: the TLD may have no RDAP service, the registry may have timed out or rate-limited the call, or the shared `.com`/`.net` daily limit may be reached. Unknown rows are free; run them again later.

**Can I send the same name twice?** Yes; duplicates (also `Example.com` vs `https://example.com/`) are merged and checked and charged once.

### More tools from the same developer

- [Domain Name Generator](https://apify.com/ucchiii/domain-name-ideas) — domain name ideas from keywords: combinations, prefixes, suffixes, blends and TLDs, scored (offline, not availability-checked)
- [Domain Age Checker](https://apify.com/ucchiii/domain-age-checker) — how old is a domain: registration date, age in years and days and an age band for up to 1,000 domains, oldest first
- [Domain WHOIS & DNS Lookup](https://apify.com/ucchiii/domain-whois) — bulk WHOIS (RDAP) and DNS lookup: registrar, expiry, days left, A/MX/NS, no personal data
- [DNS Lookup](https://apify.com/ucchiii/dns-records-lookup) — bulk DNS lookup: A, AAAA, MX, NS, TXT, SPF and DMARC per domain
- [Domain Expiry Checker](https://apify.com/ucchiii/domain-expiry-checker) — expiry dates of your own and your clients' domains in bulk, soonest first, with an N-days filter

# Actor input Schema

## `domains` (type: `array`):

Domain names to check, e.g. 'example.com'. Send them as a JSON array from code. URLs ('https://www.example.com/page') are cut down to the host name, letters are lowercased, internationalized names (münchen.de) become punycode and duplicates are removed. Up to 1,000 names per run. Leave empty to run a free demo (not charged). Do not use this Actor to register names that contain someone else's trademark or brand (cybersquatting) or for impersonation.

## `details` (type: `boolean`):

Off (default): each row has only domain, available, status, tld, checkedAt and error. On: rows also carry the registrar, its IANA ID, created / updated / expiry dates, days to expiry, registry status codes, nameservers and how the answer was decided. Same price either way.

## `concurrency` (type: `integer`):

How many names are checked in parallel. Allowed range 1 to 25 (default 10). Whatever you set, at most 2 connections go to one registry server at a time, with at least 0.25 s between requests to the same server, so a long list in one TLD is paced by that registry.

## `timeoutSecs` (type: `integer`):

Timeout for each request, in seconds (default 5, range 1 to 60). Failed requests (rate limits, server errors, timeouts) are retried up to 3 times with a growing pause; a name that still gets no answer comes back unknown and is not charged.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "python.org",
    "this-domain-should-not-exist-9f3k2.com"
  ],
  "details": false,
  "concurrency": 10,
  "timeoutSecs": 5
}
```

# Actor output Schema

## `results` (type: `string`):

One row per domain in the default dataset: domain, available (true/false/null), status, tld, checkedAt, error. Get them as JSON, CSV or Excel from the dataset API.

## `summary` (type: `string`):

Record SUMMARY: how many names were registered, available, unknown or invalid, how many were charged, and how many .com/.net names were skipped because of the shared daily limit.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "python.org",
        "this-domain-should-not-exist-9f3k2.com"
    ],
    "details": false,
    "concurrency": 10,
    "timeoutSecs": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("ucchiii/domain-availability-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "apify.com",
        "python.org",
        "this-domain-should-not-exist-9f3k2.com",
    ],
    "details": False,
    "concurrency": 10,
    "timeoutSecs": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("ucchiii/domain-availability-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "python.org",
    "this-domain-should-not-exist-9f3k2.com"
  ],
  "details": false,
  "concurrency": 10,
  "timeoutSecs": 5
}' |
apify call ucchiii/domain-availability-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ucchiii/domain-availability-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Co5w9d8LSlTfFUBnh/builds/4hKPoTSVc4D4QJ4dT/openapi.json
