Domatron CLI

High-volume domain candidate generator that creates files with 2,000+ available .com domains for downstream processing.

Overview

Domatron is a candidate generation system designed for use with Claude Code that:

Accepts free-form natural language briefs via /domains:start slash command
Generates large volumes of domain name candidates using adaptive AI strategies
Checks availability using 2-stage verification (DNS → RDAP via rotating proxy)
Saves all available domains to a file (no user output of domain names)
Reports progress only (strategy updates, success rates, counts)
Auto-generates filenames, deduplicates, and shuffles final output

Goal: Populate an output file with 2,000 available domains (or 1,000+ minimum) for downstream processing by larger models.

NOT the goal: Creating curated lists, showing domains to users, or scoring/ranking names. This is purely a high-volume candidate generation pipeline.

Installation

npm install -g domatron-cli

Configuration

Proxy Setup (Recommended)

For high-volume domain checking, configure a rotating proxy to avoid rate limiting from RDAP servers:

Sign up for a proxy service: Webshare.io (recommended)
Copy .env.example to .env in your project directory
Add your proxy credentials:

# .env
WEBSHARE_PROXY=p.webshare.io:80
WEBSHARE_AUTH=username:password

The proxy is automatically used for all RDAP queries (Stage 2 verification), while DNS queries use public resolvers (Cloudflare/Google).

Without proxy: You can still use Domatron, but may experience rate limiting on high-volume generation sessions.

Quick Start

AI-Powered Generation (Recommended)

Use the /domains:start slash command in Claude Code:

/domains:start tech SaaS platform for project management, modern short names, prefer .com and .io

Or provide a detailed brief:

/domains:start wellness coaching business targeting millennials, warm and approachable tone,
avoiding clinical terms, prefer 2-word compounds, .com only

The AI will:

Interpret your brief (industry, tone, length preferences, TLD preferences)
Auto-generate a filename (e.g., output/wellness-coaching-names.txt)
Generate candidates using multiple adaptive strategies
Check availability using 2-stage verification (DNS → RDAP via proxy)
Append available domains to file silently
Report progress only (e.g., "Strategy: Compounds; Checked 250, Found 38 (15%); Progress: 487/2000")
Complete when 2,000 available domains are saved (or 1,000+ if availability is very low)

You never see the domain names - just progress updates and completion confirmation.

Understanding the `/domains:start` Command

The slash command is a Claude Code feature that expands into a full prompt for AI-powered domain generation. When you type:

/domains:start tech SaaS for project management, modern short names

Claude Code automatically:

Interprets your brief - Extracts industry, tone, length, TLD preferences
Generates filename - Creates output/[keywords]-names.txt
Runs generation loop - Uses adaptive strategies (compounds, variations, coined patterns)
Checks availability - Verifies each batch using 2-stage DNS → RDAP
Appends to file - Saves only available domains, deduplicates automatically
Reports progress - Shows strategy, success rate, and count (e.g., "Progress: 487/2000")
Shuffles on completion - Randomizes final list for diverse downstream processing

No configuration needed - The command handles everything from filename generation to final shuffle.

Manual Tools

For advanced users who want direct control, three CLI tools are available:

1. Append available (primary):

npx append-available output/candidates.txt example.com awesome.com

2. Check availability (diagnostic):

npx check example.com awesome.com

3. Generate combinations:

npx combine Bolt Spark Yield Vault
# Outputs: BoltSpark.com, BoltYield.com, SparkVault.com, etc.

4. Generate variations:

npx variations Flux all
# Outputs: Blux.com, Clux.com, Flax.com, Flex.com, Fluxly.com, etc.

Generation Tools

Tool 1: Append Available (`npx append-available`) - PRIMARY

All-in-one tool for checking, appending, deduplicating, and optional shuffling.

# Simple usage - just pass domains directly as arguments
npx append-available output/file.txt domain1.com domain2.com domain3.com

# With JSON output (recommended)
npx append-available output/file.txt domain1.com domain2.com domain3.com --json

# With TLD expansion (for bare names)
npx append-available output/file.txt bolt spark --append-if-missing --tlds .com,.ai --shuffle-when 1000

Features:

2-stage verification (DNS → RDAP via rotating proxy)
Automatic file append with case-insensitive deduplication
Optional shuffle at threshold
JSON statistics output (add --json flag)
No domain limit
Auto-creates output directory
Verbose mode available (--verbose or -v)

Tool 2: Domain Checker (`npx check`) - DIAGNOSTIC

Quick availability check for ad-hoc testing.

# Check single domain
npx check example.com

# Check multiple (unlimited)
npx check domain1.com domain2.com domain3.com

# Output: Available domains only, one per line

Features:

2-stage verification (DNS → RDAP via proxy)
Routes through configured proxy for RDAP queries
Caches RDAP results (5 minutes)
No domain limit
Verbose mode available (--verbose or -v)

Tool 3: Combination Generator (`npx combine`)

Generates all 2-word combinations from a word list.

# Basic usage
npx combine Alpha Beta Gamma
# Output:
# AlphaBeta.com
# AlphaGamma.com
# BetaAlpha.com
# BetaGamma.com
# GammaAlpha.com
# GammaBeta.com

# Industry-specific
npx combine Bolt Spark Flash × Yield Vault Mint
# Generates: BoltYield.com, SparkVault.com, FlashMint.com, etc.

# Chain with checker
npx check $(npx combine Bold Swift Peak × Pay Fund Trade)

How it works:

Takes N words, generates N×(N-1) combinations
Outputs in CamelCase.com format
10 words = 90 combinations
20 words = 380 combinations

Tool 4: Variation Generator (`npx variations`)

Generates letter and pattern variations of a word.

# All strategies (default)
npx variations Bolt all
# Output: Boltly.com, Boltar.com, Colts.com, Jolt.com, Balt.com, etc.

# Specific strategies
npx variations Flux first-letter  # Letter substitution
npx variations Spark vowel-swap   # Vowel changes
npx variations Vault suffix       # Add suffixes
npx variations Mint prefix        # Add prefixes

# Chain with checker
npx check $(npx variations Spark all | head -50)

Strategies:

first-letter: Substitutes first letter (Vox → Box, Fox, Lox...)
vowel-swap: Changes vowels (Vox → Vax, Vex, Vix...)
suffix: Adds suffixes (Vox → Voxly, Voxar, Voxen...)
prefix: Adds prefixes (Vox → ProVox, MaxVox, ZenVox...)
all: Runs all strategies (50+ variations)

How AI Generation Works

Brief Format

The /domains:start command accepts free-form briefs that can include:

Core elements:

Industry/niche (required): "fintech startup", "wellness coaching", "AI SaaS"
Target audience: "targeting millennials", "for developers", "B2B enterprise"
Tone/style: "modern and technical", "warm and approachable", "professional"
Length preferences: "short names", "prefer 2-word compounds", "6-8 characters"
Avoided patterns: "avoid -ify suffixes", "no technical jargon", "skip animal names"
TLD preferences: "prefer .com and .io", ".com only", "include .ai and .co"

Example briefs:

# Minimal
/domains:start tech startup for developers, modern short names

# Detailed
/domains:start eco-friendly e-commerce platform targeting Gen Z,
playful and energetic tone, avoid clinical terms, 2-word compounds preferred,
.com and .co only

# With constraints
/domains:start financial planning SaaS for small businesses,
trustworthy professional tone, no crypto/blockchain terms,
prefer real-word compounds over invented names, .com preferred

Adaptive Strategy System

The AI uses multiple strategies organically and pivots based on success rate:

Strategy 1: Prefix × Suffix Matrix

Combines word banks for high volume
Example: [Bolt, Spark, Flash] × [Yield, Vault, Mint]
Generates 100s-1000s of combinations

Strategy 2: Letter Substitution

Systematic variations using variations tool
Example: Vox → Box, Fox, Lox, Nox, Pox...
25-50 variations per base word

Strategy 3: Coined Patterns

CV, CVC, CVCV patterns
Example: Zara, Kava, Mira, Qora, Xyla
High availability rate

Strategy 4: Industry Blends

Context-specific combinations
Tech: Code + [Forge, Vault, Hub]
Finance: Yield + [Bolt, Swift, Peak]

Strategy 5: Three-Letter Roots

CVC + common suffixes
Example: Bol + [tly, tar, ten, tia]

Adaptive Pivoting

Strategy: Compound Matrix
Success rate: 24% → Continue
Success rate: 18% → Continue
Success rate: 12% → Pivot to variations!

Strategy: Letter Variations
Success rate: 31% → Excellent, continue
Success rate: 28% → Still good
Success rate: 14% → Pivot to coined patterns!

Strategy: Coined Patterns
Success rate: 35% → Great, continue...

Pivot logic:

Success rate > 25%: Excellent, double down
Success rate 15-25%: Good, continue
Success rate < 15%: Switch strategies

Progress Reporting

Only progress updates are shown - never domain names:

Starting generation for fintech → candidates.txt

Strategy: Prefix×Suffix Matrix
Progress: 34/2000 (23% success rate)

Continuing matrix approach...
Progress: 156/2000 (21% rate)

Pivoting to letter variations...
Progress: 294/2000 (31% rate)

Strategy: Coined Patterns
Progress: 534/2000 (35% rate)

Continuing coined patterns...
Progress: 891/2000 (33% rate)

Back to matrix with fresh words...
Progress: 1,203/2000 (19% rate)

Final push with variations...
Progress: 1,789/2000 (26% rate)

Last batch...
Progress: 2000/2000 ✓

Complete! 2000 available domains saved to candidates.txt

Workflow Examples

Example 1: Generate Domains with Slash Command

Command:

/domains:start wellness coaching for busy professionals, warm approachable tone,
prefer 2-word real-word compounds, avoid medical jargon, .com only

AI executes:

Interprets brief → industry: wellness coaching, tone: warm, constraints: no medical terms
Auto-generates filename: output/wellness-coaching-names.txt
Starts with compound strategy using wellness + professional terms
Checks batches, tracks success rate
Pivots to variations when rate drops
Tries coined patterns for fresh candidates
Reports progress: "Strategy: Compounds; Checked 250, Found 42 (17%); Progress: 487/2000"
Saves all available domains to file silently

Output: output/wellness-coaching-names.txt with 2,000 available domains

Console output (example):

Starting generation for wellness coaching → output/wellness-coaching-names.txt

Strategy: Compound names (wellness-focused)
Checked 250, found 42 (17% rate)
Progress: 42/2000

Continuing compounds...
Checked 200, found 38 (19% rate)
Progress: 80/2000

Strategy: Letter variations
Checked 300, found 51 (17% rate)
Progress: 131/2000

...

Complete! 2,004 available domains saved to output/wellness-coaching-names.txt

Example 2: Manual Generation Pipeline

# 1. Generate combinations
npx combine Vital Pure Heal × Flow Path Root > batch1.txt

# 2. Check availability
npx check $(cat batch1.txt) > available1.txt

# 3. Generate variations
npx variations Zen all > batch2.txt
npx check $(cat batch2.txt) > available2.txt

# 4. Combine results
cat available1.txt available2.txt > candidates.txt

# 5. Check count
wc -l candidates.txt

Example 3: Industry-Specific Generation

Tech/SaaS:

npx combine Code Data Cloud Sync × Forge Vault Hub Flow | npx check

Finance:

npx combine Yield Hedge Fund × Bolt Swift Peak Prime | npx check

E-commerce:

npx combine Shop Buy Get × Joy Easy Swift Fast | npx check

Output Format

File structure (candidates.txt):

BoltYield.com
SparkVault.com
FlashMint.com
ZenithHub.com
Zelara.com
Voxlyn.com
...
[1994 more lines]

One domain per line
CamelCase format
Append mode (never overwrites)
No headers, no comments
Ready for downstream processing

Filtering & Acceptance

Minimal filtering - accept most names:

Auto-reject only:

Length > 15 characters
3+ consecutive consonants
Contains numbers/special chars
Obvious misspellings (Gogle, Fcebook)

Auto-accept everything else:

Any reasonable compound
Any pronounceable coined name
Any variation that looks OK
Volume over perfection

Performance Targets

With 2-stage verification (DNS → RDAP via proxy):

Small batch (100 domains):

~500 candidates generated
Time: 5-10 minutes
Expected success rate: 10-30%

Medium batch (500 domains):

~2,500 candidates generated
Time: 20-40 minutes
Expected success rate: 15-25%

Large batch (2,000 domains):

~10,000-15,000 candidates generated
Time: 2-4 hours
Expected success rate: 10-30%
Early quit acceptable at 1,000+ domains if rates consistently <10%

Performance characteristics:

Slower than DNS-only checking (~3-4x) but zero false positives
RDAP proxy prevents rate limiting for high-volume sessions
Success rates lower but more accurate (every "available" domain is truly unregistered)
Niche/specific terminology performs 2-3x better than generic tech terms

Programmatic Usage

import { checkDomains } from 'domatron-cli';

// Check domains
const results = await checkDomains([
  'boltyield.com',
  'sparkvault.com'
]);

console.log(results.available);   // ['boltyield.com']
console.log(results.unavailable); // ['sparkvault.com']
console.log(results.total);       // 2

Options

const results = await checkDomains(domains, {
  concurrency: 10,              // Parallel requests
  dnsServers: ['1.1.1.1']      // DNS servers
});

Domain Checking Details

2-Stage Verification (DNS → RDAP)

Stage 1: DNS Evidence (Fast Filter)

Checks A, AAAA, CNAME, NS, SOA, MX, TXT records
2.5s timeout per lookup
Uses Cloudflare (1.1.1.1) and Google (8.8.8.8) public DNS
If ANY records exist → domain is taken, skip Stage 2

Stage 2: RDAP Verification (Authoritative)

Only runs if NO DNS evidence found
Queries IANA RDAP bootstrap for correct registry
Routes through Webshare rotating proxy (configured in .env)
5s timeout
HTTP 200 = domain registered (taken)
HTTP 404 = domain not registered (available)
Standardized JSON response, works across all TLDs

Why RDAP is superior to DNS-only:

Authoritative registration status directly from domain registries
Zero false positives (DNS-only misses parked domains)
Designated by ICANN as official domain availability protocol
Machine-readable, consistent across all registries

Conservative Approach

Timeouts/errors → marked unavailable (prefer false negatives)
RDAP results cached 5 minutes
DNS lookups not proxied (uses public resolvers)
Proxy only used for RDAP queries (avoids rate limiting)

Validation

All valid TLDs supported (.com, .au, .io, .co, .com.au, etc.)
PSL-aware validation via tldts library
Lowercase letters, numbers, hyphens
No leading/trailing hyphens
1-63 characters per label, 253 max total

Requirements

Node.js >= 18.0.0
Network connection (DNS + WHOIS)
No external API keys needed

Project Structure

domatron-cli/
├── bin/
│   ├── check.js       # Domain availability checker
│   ├── combine.js     # Word combination generator
│   └── variations.js  # Pattern variation generator
├── lib/
│   ├── check-domains.js
│   └── index.js
├── CLAUDE.md          # AI generation strategies
├── package.json
└── README.md

Use Cases

Startup founders: Generate 2,000+ domain options for business naming, providing a large pool for downstream selection Brand agencies: Bulk candidate generation for client presentations across multiple industries AI pipelines: Feed large language models with raw domain candidates for intelligent filtering and ranking Domain researchers: Study domain name availability patterns and namespace saturation Side project creators: Quickly find available domains for new projects without manual searching Portfolio builders: Generate and secure domains in bulk for future ventures

Key Principles

Volume over quality - Accept any reasonable name, filter downstream
Accuracy over speed - 2-stage verification ensures zero false positives
Organic adaptation - Switch strategies based on success rate
Silent operation - Only report progress, never show domains
File-focused - Everything appends to output file automatically
Proxy-enabled - Rotating proxy prevents rate limiting on high-volume sessions
Brief-driven - Free-form natural language input via /domains:start
Auto-everything - Filenames, deduplication, and shuffling handled automatically

FAQ

Q: Do I need a proxy to use Domatron? A: No, but it's highly recommended for high-volume generation (500+ domains). Without a proxy, you may hit rate limits from RDAP servers. For small batches (<100 domains), the built-in DNS + RDAP checking works fine.

Q: How much does the Webshare proxy cost? A: Webshare offers a free tier with 10 proxies and 250MB bandwidth, sufficient for small-scale testing. Paid plans start at $2.99/month for higher volume.

Q: Can I use this without Claude Code? A: Yes! The CLI tools (npx check, npx append-available, npx combine, npx variations) work standalone. The /domains:start slash command is Claude Code-specific, but you can manually orchestrate the tools.

Q: Why are success rates lower than expected? A: The 2-stage verification (DNS → RDAP) is highly accurate but conservative. .com namespace is heavily saturated - expect 10-30% success rates. Niche/specific terminology performs better than generic tech terms.

Q: How do I stop verbose logging? A: By default, proxy configuration logs are suppressed. To see debug output, add --verbose or -v flag to commands.

Q: Can I check non-.com domains? A: Yes! Domatron supports all valid TLDs (.io, .ai, .co, .com.au, etc.). Just specify in your brief: "prefer .io and .ai"

License

MIT

Support

Issues & Bug Reports: https://github.com/gregpriday/domatron/issues
AI Strategy Details: See CLAUDE.md for detailed generation strategies and patterns
Slash Command Reference: See .claude/commands/domains/start.md for command documentation
Proxy Setup: Webshare.io for rotating proxy service

Contributing

Contributions welcome! Please open an issue or PR on GitHub.

Credits

Built with Claude Code for high-volume domain candidate generation.

Name		Name	Last commit message	Last commit date
Latest commit History 33 Commits
.claude		.claude
__mocks__		__mocks__
bin		bin
lib		lib
output		output
strategies		strategies
test		test
.babelrc		.babelrc
.env.example		.env.example
.gitignore		.gitignore
.npmignore		.npmignore
CLAUDE.md		CLAUDE.md
README.md		README.md
jest.config.js		jest.config.js
package-lock.json		package-lock.json
package.json		package.json

gregpriday/domatron

Folders and files

Latest commit

History

Repository files navigation