How to Build a Domain Availability Checker with Python

How to Build a Domain Availability Checker with Python

Finding the perfect domain name is a grind. In this tutorial, we will build a Python tool that checks domain availability in bulk, suggests alternatives, and monitors expiring domains.

Setup

pip install python-whois requests

Basic WHOIS Checker

import whois
import time

def check_domain(domain):
    try:
        w = whois.whois(domain)
        if w.domain_name:
            return {
                "domain": domain,
                "available": False,
                "registrar": w.registrar,
                "creation_date": str(w.creation_date),
                "expiration_date": str(w.expiration_date)
            }
    except whois.parser.PywhoisError:
        return {"domain": domain, "available": True}
    except Exception as e:
        return {"domain": domain, "available": None, "error": str(e)}

    return {"domain": domain, "available": True}

result = check_domain("example.com")
print(result)

Bulk Checker

import pandas as pd

def bulk_check(domains, delay=1):
    results = []
    for i, domain in enumerate(domains):
        print(f"Checking {i+1}/{len(domains)}: {domain}")
        result = check_domain(domain)
        results.append(result)
        time.sleep(delay)

    return pd.DataFrame(results)

base = "myproject"
tlds = [".com", ".io", ".dev", ".app", ".co", ".net", ".org", ".ai"]
domains = [f"{base}{tld}" for tld in tlds]

df = bulk_check(domains)
available = df[df["available"] == True]
print(f"\nAvailable domains ({len(available)}):")
for _, row in available.iterrows():
    print(f"  {row['domain']}")

Smart Name Generator

import itertools

def generate_domain_ideas(keyword, max_results=50):
    prefixes = ["get", "try", "use", "go", "my", "the", "hey"]
    suffixes = ["app", "hq", "io", "dev", "hub", "lab", "now"]
    tlds = [".com", ".io", ".dev", ".app", ".co"]

    ideas = []
    for prefix in prefixes:
        for tld in tlds:
            ideas.append(f"{prefix}{keyword}{tld}")
    for suffix in suffixes:
        for tld in tlds:
            ideas.append(f"{keyword}{suffix}{tld}")
    for tld in tlds:
        ideas.append(f"{keyword}{tld}")

    return ideas[:max_results]

ideas = generate_domain_ideas("scraper")
print(f"Generated {len(ideas)} domain ideas")

DNS-Based Quick Check

WHOIS is slow and rate-limited. For a fast initial filter, use DNS:

import socket

def quick_dns_check(domain):
    try:
        socket.getaddrinfo(domain, None)
        return False  # Has DNS records = likely registered
    except socket.gaierror:
        return True   # No DNS = possibly available

candidates = generate_domain_ideas("databot")
quick_available = [d for d in candidates if quick_dns_check(d)]
print(f"Possibly available: {len(quick_available)}/{len(candidates)}")

verified = bulk_check(quick_available[:20], delay=2)

Monitoring Expiring Domains

from datetime import datetime, timedelta

def check_expiring(domains, days_threshold=30):
    expiring = []
    for domain in domains:
        result = check_domain(domain)
        if not result.get("available") and result.get("expiration_date"):
            try:
                exp_date = datetime.strptime(
                    result["expiration_date"].split("[")[0].strip(),
                    "%Y-%m-%d %H:%M:%S"
                )
                days_left = (exp_date - datetime.now()).days
                if 0 < days_left <= days_threshold:
                    expiring.append({
                        "domain": domain,
                        "expires": exp_date.isoformat(),
                        "days_left": days_left
                    })
            except (ValueError, AttributeError):
                pass
        time.sleep(1)

    return sorted(expiring, key=lambda x: x["days_left"])

Scaling with Proxies

WHOIS servers aggressively rate-limit. For bulk checking, use ScraperAPI to distribute requests across IPs. For checking domains across different registrars, ThorData residential proxies help avoid blocks. ScrapeOps can monitor your check success rates across providers.

Building a CLI Tool

import argparse

def main():
    parser = argparse.ArgumentParser(description="Domain Availability Checker")
    parser.add_argument("keyword", help="Base keyword for domain search")
    parser.add_argument("--tlds", nargs="+", default=[".com", ".io", ".dev"])
    parser.add_argument("--check-all", action="store_true")
    args = parser.parse_args()

    ideas = generate_domain_ideas(args.keyword)
    print(f"Checking {len(ideas)} domain variations...")

    if args.check_all:
        results = bulk_check(ideas)
        available = results[results["available"] == True]
        print(f"\n{len(available)} available domains found!")
    else:
        quick = [d for d in ideas if quick_dns_check(d)]
        print(f"\n{len(quick)} possibly available (DNS check)")
        for d in quick:
            print(f"  {d}")

if __name__ == "__main__":
    main()

Tips

1. Cache WHOIS results — results are valid for hours, no need to re-check
2. Use DNS first — 10x faster than WHOIS for initial filtering
3. Respect rate limits — WHOIS servers will ban you (1-2 second delays minimum)
4. Check multiple TLDs — .io and .dev often available when .com is taken
5. Monitor auctions — expiring premium domains can be snagged at auction

---

Follow for more Python utility tutorials!