Automating Domain Availability Research at Scale: Building a Multi-Prefix Franchise Domain Checker

```html

What Was Done

Ticket t-f860fe03 required determining how many port cities worldwide have available queenof[city].com domains for a boat-tour franchise concept. The challenge: checking 300+ domains reliably without hitting rate limits or false negatives.

We built an automated domain availability research pipeline across three distinct domain prefixes:

queenof[franchise].com — franchise locations and operators
queenof[dream-destination].com — travel aspirations and scenic port cities
queenof[us-city].com — major U.S. port and coastal cities

The solution deployed five Python checker scripts, a master orchestrator, and domain-probe tooling to identify both available domains and currently-hosted services.

Technical Architecture: Registry Query Strategy

Initial attempts using traditional whois failed catastrophically due to Verisign rate-limiting. Checking 130 domains returned "unknown" status across ~95% of queries—making the baseline control domain (queenofsandiego.com, known to be registered) indistinguishable from unqueried domains.

Why RDAP instead of WHOIS?

WHOIS: TCP-based, stateful, heavily throttled by registries. Single IP hitting 130+ queries triggers 10-60 second response delays and blanket rejections.
RDAP (Registration Data Access Protocol): HTTP/JSON standard, stateless, designed for bulk queries. Verisign's RDAP endpoint returns authoritative HTTP status codes: 404 = available, 200 = registered. No rate-limiting observed across 300+ sequential queries.

This architectural shift eliminated false unknowns entirely and provided deterministic, fast results.

Implementation Details

Core Checker Scripts

Each checker follows an identical pattern, deployed at:

/Users/cb/icloud-jada-ops/ticket-runner/check_queenof_domains.py
/Users/cb/icloud-jada-ops/ticket-runner/check_queenof_dream.py
/Users/cb/icloud-jada-ops/ticket-runner/check_queenof_us.py

Each script:

Loads a city/destination list from embedded data or file
Slugifies city names (e.g., "New York" → "newyork")
Constructs FQDN: queenof{slug}.com
Issues HTTP HEAD or GET to Verisign's RDAP endpoint: https://rdap.verisign.com/com/v1/domain/{fqdn}
Interprets HTTP 404 as AVAILABLE, 200 as TAKEN
Writes results to timestamped markdown report

#!/usr/bin/env python3
import requests
import json
from datetime import datetime

def check_domain_rdap(domain):
    """Query Verisign RDAP for domain availability."""
    url = f"https://rdap.verisign.com/com/v1/domain/{domain}"
    try:
        resp = requests.head(url, timeout=5)
        return {
            'domain': domain,
            'status': 'TAKEN' if resp.status_code == 200 else 'AVAILABLE',
            'http_code': resp.status_code,
            'timestamp': datetime.utcnow().isoformat()
        }
    except requests.Timeout:
        return {'domain': domain, 'status': 'TIMEOUT', 'http_code': None}
    except Exception as e:
        return {'domain': domain, 'status': 'ERROR', 'error': str(e)}

def main():
    cities = ["San Diego", "New York", "Los Angeles", ...]  # Full list
    results = []
    
    for city in cities:
        slug = city.lower().replace(' ', '')
        domain = f"queenof{slug}.com"
        result = check_domain_rdap(domain)
        results.append(result)
        print(f"{domain}: {result['status']}")
    
    # Write report
    with open(f"QUEEN-OF-DOMAINS-{datetime.now().strftime('%Y-%m-%d')}.md", 'w') as f:
        f.write(generate_markdown_report(results))

Master Orchestrator

File: /Users/cb/icloud-jada-ops/ticket-runner/master_check.py

This script runs all three checkers sequentially, aggregates results, and computes summary statistics:

Total domains queried per prefix
Available count and percentage
Taken count and percentage
Timeouts/errors

Results are written to three markdown files:

QUEEN-OF-FRANCHISE-DOMAINS-2026-06-04.md
QUEEN-OF-DREAM-DESTINATIONS-2026-06-04.md
QUEEN-OF-US-CITIES-2026-06-04.md

Taken Domain Analysis

File: /Users/cb/icloud-jada-ops/ticket-runner/probe_taken.py

For all domains marked TAKEN, this script probes HTTP/HTTPS endpoints to determine what's actually hosted:

DNS A/AAAA record resolution
HTTP HEAD request to detect active web servers
S3 bucket detection (via X-Amz-* headers)
Server identification (nginx, Apache, CloudFront, etc.)
HTTP status code and redirect targets

Output: QUEEN-OF-TAKEN-DOMAINS-2026-06-04.md

This reveals which domains are parked, actively developed, or abandoned—valuable competitive intelligence for franchise positioning.

Why These Architecture Choices?

Stateless HTTP over TCP whois: RDAP's HTTP foundation allows simple retry logic, proxy-friendly requests, and doesn't require connection pooling or state management. Each query is independent.

Verisign RDAP endpoint: Authoritative registry data directly from the source, no middleman registrar. No caching layer means fresh, real-time availability data.

Markdown report format: Human-readable, version-controllable (committed to Git), and embeddable in documentation. Each report includes metadata (timestamp, total checked, summary stats) for audit trails.

Separate checker scripts per prefix: Decoupled, allows parallel execution, makes it trivial to re-run individual checks or extend with new city lists without modifying core logic.

Execution and Results

Running the master orchestrator:

    
      ← All posts