The Million Domain Method: How I Check 100,000+ Domains for Availability While I Sleep

Most bulk domain search tools cap you at 100 to 500 domains, take forever to return results, and make you click through annoying interfaces just to export anything useful. If you have ever tried to check thousands of domain names for availability, you know exactly what I mean.

There is a better way. With a simple Python script and the free name.com API, you can check hundreds of thousands of domains in the background while you work on other things. When the script finishes, you are left with a clean CSV file containing only the domains that are actually available to register.

This is one of my favorite methods for finding hand registration opportunities when I am not using the DomainBFF Name Generator. Instead of manually checking small batches and dealing with the constraints of most bulk domain lookup tools at GoDaddy or Dynadot, I can generate massive lists of potential domains, run them through this script overnight, and wake up to a curated list of available names worth researching further.

Why Bulk Checking Changes Everything

The math behind bulk domain checking makes it one of the most efficient domain research strategies available. If you pair 500 prefixes with 500 suffixes, you generate 250,000 potential domain combinations. Checking those one at a time would take months. With a script running in the background, you can process that entire list in a few hours.

The goal is not to register everything that comes back available. Most available domains are available for a reason. But when you check 100,000+ domains, you only need a handful of quality names to make the entire process worthwhile. One solid hand registration that sells for $500 to $5,000 more than pays for the time investment.

This method works especially well for finding keyword combinations that slipped through the cracks, recently expired domains that were not renewed, brandable names using proven prefix/suffix patterns, and industry-specific domains with real business demand.

The Keyword Pairing Strategy

The quality of your results depends entirely on the quality of your input list. Random word combinations will give you random, mostly worthless results. The key is pairing proven prefixes and suffixes that have actual sales history and market demand.

Finding Proven Prefixes and Suffixes

I use two main sources to build my keyword lists.

The Top Keywords Tool shows you the most-registered domain keywords by TLD. If thousands of domainers have registered variations of a keyword, that is a strong signal of market demand. Look for patterns in how these keywords are used as prefixes (keyword + something) versus suffixes (something + keyword).

The Domain Sales History Tool gives you actual sales data that tells you what buyers are paying for. Search for domains with similar patterns to what you want to register. If "TechSolutions.com" sold for $15,000 and "DataSolutions.com" sold for $8,500, you know that "[Keyword]Solutions.com" is a proven pattern worth exploring.

Export lists of keywords from both tools. Focus on keywords that appear frequently in sales data and have high registration counts. These are your foundation for building a targeted domain list.

Sample prefixes with proven sales history: Tech, Smart, Digital, Cloud, Data, Cyber, Net, Web, Online, Pro, Elite, Prime, Alpha, Apex, Peak, Top, Best, First, Quick, Fast, Easy, Simple, Direct, Instant, Express, Global, Metro, Local, City, National, Regional, American, Green, Eco, Solar, Clean, Pure, Natural, Organic.

Sample suffixes with proven sales history: Solutions, Services, Systems, Group, Labs, Works, Hub, Tech, AI, Pro, Plus, Max, Now, Go, Up, HQ, IO, Shop, Store, Market, Trade, Buy, Deals, Direct, Health, Care, Med, Doc, Clinic, Dental, Medical, Home, House, Property, Realty, Homes, Living, Space.

Using AI to Generate Your Domain List

Once you have your prefix and suffix lists, you can use ChatGPT, Claude, Grok, or any AI assistant to combine them into a domain list. Here is a sample prompt:

I have a list of prefixes and a list of suffixes. Please combine every prefix with every suffix to create domain names, then append ".com" to each one.

Output the results as a plain text list with one domain per line, no numbering, no extra formatting.

PREFIXES:
Tech, Smart, Digital, Cloud, Data, Quick, Fast, Easy, Pro, Elite

SUFFIXES:
Solutions, Services, Systems, Hub, Labs, Works, Group, HQ, Now, Pro

Generate all combinations.

With 10 prefixes and 10 suffixes, you get 100 domain combinations. Scale that up to 500 prefixes and 500 suffixes and you have 250,000 potential domains to check.

For larger lists, ask the AI to export the results as a downloadable .txt or .csv file. Most AI tools can generate files containing tens of thousands of lines without issue.

Setting Up the name.com API (Free)

The name.com API is free to use and allows you to check domain availability in batches of 50 at a time. This is significantly faster than checking domains one by one through a web interface.

Create a name.com Account:

1. Go to name.com and create a free account if you do not have one
2. Verify your email address
3. Log in to your account

Generate Your API Token:

1. Once logged in, go to Account Settings
2. Click on API Token in the left sidebar (or navigate directly to name.com/account/settings/api)
3. Click Generate new token
4. Copy and save your API token somewhere secure. You will need this for the script.

Important: Your API token is like a password. Do not share it publicly or commit it to public code repositories.

Your name.com username is the email address or username you use to log in. You will need both your username and API token to authenticate API requests.

Installing Python

If you do not already have Python installed, here is how to set it up.

Windows:

1. Go to python.org/downloads
2. Download the latest Python 3.x installer
3. Run the installer and check the box that says "Add Python to PATH"
4. Click "Install Now"
5. Open Command Prompt and type python --version to verify installation

Mac:

1. Open Terminal
2. Install Homebrew if you do not have it: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
3. Install Python: brew install python
4. Verify installation: python3 --version

Linux: Most distributions come with Python pre-installed. Open Terminal and run python3 --version. If not installed, use your package manager (sudo apt install python3 python3-pip for Ubuntu/Debian).

Install the Requests Library: The script uses the requests library to make API calls. Install it by running pip install requests (Windows) or pip3 install requests (Mac/Linux).

The Bulk Domain Checker Script

Create a new file called domain_checker.py and paste the following code. Then update the API_USER and API_TOKEN values with your name.com credentials.

#!/usr/bin/env python3
"""
Bulk Domain Availability Checker
Uses the name.com Core API to check domain availability in batches.
Results are streamed to a CSV file as they are found.

Setup:
1. Set your name.com username and API token below
2. Create a file called "check_names.txt" with one domain per line
3. Run: python domain_checker.py
4. Available domains will be saved to "available_domains.csv"
"""

import os
import sys
import csv
import time
import math
import requests

# Configuration - Edit these values
API_USER = "YOUR_USERNAME_HERE"      # Your name.com username
API_TOKEN = "YOUR_API_TOKEN_HERE"    # Your API token from name.com/account/settings/api

# File settings
INPUT_FILE = "check_names.txt"       # Your list of domains to check
OUTPUT_FILE = "available_domains.csv" # Where available domains will be saved

# API settings
API_BASE = "https://api.name.com"
BATCH_SIZE = 50
CONNECT_TIMEOUT = 8
READ_TIMEOUT = 45
SLEEP_BETWEEN = 0.4

def load_domains(path):
    if not os.path.exists(path):
        print(f"Error: Could not find {path}")
        sys.exit(1)
    with open(path, "r", encoding="utf-8") as f:
        seen = set()
        domains = []
        for line in f:
            domain = line.strip().lower()
            if not domain.endswith(".com"):
                continue
            if domain and domain not in seen:
                domains.append(domain)
                seen.add(domain)
        return domains

def chunked(sequence, size):
    for i in range(0, len(sequence), size):
        yield sequence[i:i+size]

def ensure_csv(path):
    if not os.path.exists(path) or os.path.getsize(path) == 0:
        with open(path, "w", newline="", encoding="utf-8") as f:
            csv.writer(f).writerow(["domain"])

def append_csv(path, domains):
    if not domains:
        return
    with open(path, "a", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        for domain in domains:
            writer.writerow([domain])
        f.flush()

def check_batch(session, domains):
    url = f"{API_BASE}/core/v1/domains:checkAvailability"
    payload = {"domainNames": domains}
    response = session.post(url, json=payload, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT))
    if response.status_code != 200:
        raise RuntimeError(f"API Error {response.status_code}: {response.text[:300]}")
    return response.json().get("results", [])

def main():
    if API_TOKEN == "YOUR_API_TOKEN_HERE" or API_USER == "YOUR_USERNAME_HERE":
        print("Error: Please edit the script and add your name.com credentials.")
        sys.exit(1)
    
    domains = load_domains(INPUT_FILE)
    total = len(domains)
    total_batches = math.ceil(total / BATCH_SIZE)
    
    print(f"Checking {total:,} domains in {total_batches:,} batches...")
    
    ensure_csv(OUTPUT_FILE)
    session = requests.Session()
    session.auth = (API_USER, API_TOKEN)
    session.headers.update({"Content-Type": "application/json"})
    
    checked = 0
    found = 0
    start_time = time.time()
    
    for batch_num, batch in enumerate(chunked(domains, BATCH_SIZE), start=1):
        try:
            results = check_batch(session, batch)
        except Exception as e:
            print(f"Batch {batch_num} failed: {e}")
            time.sleep(2)
            continue
        
        available = [
            item["domainName"] for item in results
            if item.get("purchasable", item.get("available", False)) is True
            and not item.get("premium", False)
        ]
        
        append_csv(OUTPUT_FILE, available)
        found += len(available)
        checked += len(batch)
        
        percent = (checked / total) * 100
        elapsed = time.time() - start_time
        rate = checked / elapsed if elapsed > 0 else 0
        eta = (total - checked) / rate / 60 if rate > 0 else 0
        
        print(f"[{batch_num}/{total_batches}] {checked:,}/{total:,} ({percent:.1f}%) | Found: {found:,} | ETA: {eta:.1f}m")
        time.sleep(SLEEP_BETWEEN)
    
    print(f"\nDone! {found:,} available domains saved to {OUTPUT_FILE}")

if __name__ == "__main__":
    main()

The script includes error handling for failed batches, real-time progress updates, and automatic CSV streaming so you can check partial results while it runs.

Running the Script

Create a text file called check_names.txt in the same folder as your script. This file should contain one domain per line:

techsolutions.com
smartsystems.com
cloudhub.com
datapro.com
quickservices.com

Make sure each domain includes the .com extension. The script will automatically remove duplicates and normalize everything to lowercase.

Open your terminal or command prompt, navigate to the folder containing your script and domain list, then run:

python domain_checker.py

On Mac/Linux, use python3 domain_checker.py instead.

The script will display progress like this:

Checking 72,500 domains in 1,450 batches...
[1/1450] 50/72,500 (0.1%) | Found: 3 | ETA: 26.7m
[2/1450] 100/72,500 (0.1%) | Found: 5 | ETA: 25.1m
[3/1450] 150/72,500 (0.2%) | Found: 7 | ETA: 24.5m

Available domains are saved to the CSV file in real-time, so you can check partial results even while the script is still running.

Validating Your Results Before Registering

When the script finishes, open available_domains.csv to see all the domains that came back as available. This file contains only domains that are not currently registered, are purchasable at standard registration price, and are not premium domains.

Not every available domain is worth registering. Now comes the research phase.

For any domain that looks interesting, run it through additional research before spending money on registration. The Domain Search tool shows how many TLDs are already registered for the keyword. If dozens of extensions are taken, that signals market interest.

The Domain Leads Finder searches for businesses using the keyword. Real companies with matching names are potential end-user buyers.

The Sales History tool shows comparable sales. Has anything similar sold recently? What prices are realistic?

A domain that shows strong signals across all three tools is worth registering. A domain with no TLD registrations, no matching businesses, and no comparable sales is probably available for a reason.

Both the Search tool and the Leads tool are available with a single DomainBFF subscription, making it easy to run through your entire available list without switching between platforms.

Tips for Better Results

Start with quality keywords. Garbage in, garbage out. Spend time building quality prefix and suffix lists from actual sales data rather than random word generators. The Top Keywords and Domain Sales tools are your best sources for proven patterns.

Run overnight for large lists. Processing 100,000+ domains takes a few hours. Start the script before bed and check results in the morning. The script handles everything automatically and saves progress continuously.

Filter by industry. Instead of generating generic combinations, focus on specific industries where you understand buyer behavior. Tech, healthcare, real estate, and finance domains tend to have strong demand and identifiable end users.

Check multiple TLDs. The script is set up for .com by default, but you can modify the load_domains function to check other extensions. If a .com is taken but the .io or .co is available, that might still be worth registering depending on your strategy.

Bulk domain checking is one of the most scalable ways to find hand registration opportunities. While most domain investors are limited to checking a few hundred domains at a time through web interfaces, you can now process hundreds of thousands in the background. The script handles all the technical work. Your job is building quality input lists and researching the results.

The best part? Once you have the script set up, running it costs nothing. Generate new keyword combinations, check availability overnight, and review results over coffee. It is the kind of systematic approach that separates serious domain investors from those who rely on luck.