Bulk Domain Checking: A Developer's Guide

Published: March 20, 2026

Checking a single domain for availability is straightforward. Checking hundreds or thousands introduces challenges around rate limiting, latency, and data quality. This guide covers the use cases for bulk domain checking, why single-domain approaches break at scale, and how to use a batch API to check domains efficiently.

When you need bulk domain checking

Bulk domain availability checking is relevant for several workflows:

• Domain investors — screening lists of expiring or dropped domains for registration opportunities.
• Brand protection — checking whether a brand name is registered across hundreds of TLDs and common typosquatting variations.
• Startup naming tools — powering domain search features where users type a keyword and see availability across multiple extensions.
• Registrar integrations — building a domain search into an existing hosting or registrar product.
• SEO and marketing tools — identifying available domains for microsites, landing pages, or redirects.

The problem with checking one domain at a time

The naive approach — sending a separate WHOIS query for each domain — runs into hard limits quickly.

At 43 queries per minute, checking 1,000 domains via WHOIS takes over 23 minutes. With a batch API that accepts 100 domains per request at 300 requests per minute, the same 1,000 domains take under 4 seconds.

How batch domain checking works

A batch API accepts multiple domains in a single HTTP request and returns results for all of them. On the server side, the API can parallelize lookups across DNS resolvers and WHOIS clients, avoiding the serial bottleneck of one-at-a-time checking.

Request format

Send a POST request with a JSON body containing an array of domain names:

curl -X POST https://api.canyougrab.it/api/check/bulk \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"domains": ["startup.com", "startup.io", "startup.dev", "startup.co", "startup.app"]}'

Response format

The response contains a results array with one entry per domain, in the same order as the request:

{
  "results": [
    {
      "domain": "startup.com",
      "available": false,
      "confidence": "high",
      "source": "cache",
      "tld": "com",
      "checked_at": "2026-03-20T12:00:00Z"
    },
    {
      "domain": "startup.io",
      "available": false,
      "confidence": "high",
      "source": "dns",
      "tld": "io",
      "checked_at": "2026-03-20T12:00:00Z"
    },
    {
      "domain": "startup.dev",
      "available": true,
      "confidence": "medium",
      "source": "dns",
      "tld": "dev",
      "checked_at": "2026-03-20T12:00:00Z"
    }
  ]
}

Python example: checking a list of domains

import requests

API_KEY = "YOUR_API_KEY"
domains = ["mybrand.com", "mybrand.io", "mybrand.dev",
           "mybrand.co", "mybrand.app", "mybrand.net"]

resp = requests.post(
    "https://api.canyougrab.it/api/check/bulk",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"domains": domains}
)

available = [r["domain"] for r in resp.json()["results"]
             if r["available"]]
print(f"Available: {', '.join(available) or 'none'}")

Scaling beyond 100 domains per request

The API accepts up to 100 domains per request. For larger lists, split your domains into batches and send them sequentially or in parallel (within your rate limit).

Batch splitting strategy

import requests
import time

API_KEY = "YOUR_API_KEY"
all_domains = [...]  # your full list

def check_batch(domains):
    resp = requests.post(
        "https://api.canyougrab.it/api/check/bulk",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"domains": domains}
    )
    return resp.json()["results"]

# Split into chunks of 100
batches = [all_domains[i:i+100]
           for i in range(0, len(all_domains), 100)]

all_results = []
for batch in batches:
    all_results.extend(check_batch(batch))

Throughput by pricing tier

The rate at which you can check domains depends on your plan's requests-per-minute limit and the 100-domain batch size:

• Free — 30 req/min = up to 3,000 domains/min (500/month total)
• Verified — 100 req/min = up to 10,000 domains/min (10,000/month total)
• Basic — 300 req/min = up to 30,000 domains/min (20,000/month included)
• Pro — 1,000 req/min = up to 100,000 domains/min (50,000/month included)
• Business — 3,000 req/min = up to 300,000 domains/min (300,000/month included)

For most use cases, the Free or Verified tier is enough to get started. Scale up as your volume grows. See pricing details for the full breakdown.

Best practices

• Use the full batch size — always send close to 100 domains per request to maximize throughput per API call.
• Handle rate limit responses — if you receive a 429 response, wait until the top of the next UTC minute before retrying. The API resets rate limits at the start of each minute.
• Filter obvious cases first — pre-filter domains you know are taken (e.g., from your own database) to avoid wasting lookups on domains you have already checked.
• Cache results — domain availability does not change frequently. Cache results for at least a few hours to avoid redundant lookups.
• Check confidence scores — a result with "confidence": "medium" from DNS alone may warrant a re-check later. High-confidence WHOIS results are definitive.

Further reading

• How to Check Domain Availability with an API — getting started with code examples
• DNS vs WHOIS for Domain Availability Checking — understanding the data sources behind the results
• API Reference — full endpoint documentation with request and response schemas