Cross-platform, dependency-free domain availability checker — runs as a plugin in Claude Code, an extension in Gemini CLI, and a skill in Codex CLI / OpenCode, or as a plain Python CLI.
Ask your coding agent "is example.com free?" and get an evidence-backed answer with the registrar, expiration date, server IPs, and full SSL certificate inline — for any TLD on the planet, including GDPR-redacted ccTLDs like .de, .eu, .at, .ch, .es.
The
.derow legitimately has no expiry — DENIC redacts that field under GDPR. The skill says so explicitly instead of guessing.
Most domain-checker tools fail in one of three ways:
- They hit a single source and return false negatives when it's wrong.
- They require API keys and paid plans.
- They silently return "unknown" for half of all ccTLDs because GDPR redacts the registry response.
This skill solves all three:
- Five-source consensus. RDAP, WHOIS, authoritative DNS NS lookup, A/AAAA + HTTP reachability, TLS certificate. The verdict only reaches 100% confidence when sources agree.
- TLD-aware decision tree. For
.dethe only reliable signal is an authoritative NS query againsta.nic.de. For.coman RDAP no-object response is definitive. The skill picks the right strategy per TLD. - Zero dependencies, zero config. Pure Python ≥ 3.11 standard library. No
pip install, no venv, no API tokens, no rate-limited free tier. - Bulk + parallel. 30 domains in ~10–15 seconds via
asyncio. - Built for AI agents. The
SKILL.mdtells the agent when to invoke it (trigger phrases in EN + DE) and how to read the JSON output.
- Binary verdict —
Available/Taken/Reserved/Unclearwith a 0.0–1.0 confidence score - Five concurrent sources, ~2–4 s per single check
- Expiration dates for both domain registration and SSL certificate, surfaced inline whenever the registry exposes them (GDPR ccTLDs legitimately redact this — the skill says so explicitly instead of guessing)
- 30+ TLD-specific WHOIS patterns plus IANA-bootstrap fallback for any unknown TLD
- GDPR-aware: authoritative registry NS lookups for
.de,.eu,.at,.ch,.es,.li, … - Inline SSL inspection: issuer, subject, SAN, validity, fingerprint, hostname match
- IP resolution: IPv4, IPv6, reverse DNS for any URL or hostname
- Bulk mode with 8-way concurrency and NDJSON / JSON / human table output
- Naming co-pilot — generates and scores brandable domain candidates and bulk-checks the top N for actual availability
- Cross-platform: same commands on Linux, macOS, Windows
- Implements the Agent Skills open standard
This repo ships as both a Claude Code plugin and a Gemini CLI extension, with a manifest for each. The skill itself lives in skills/domain-check/.
Once the plugin is listed in the official marketplace, install with:
/plugin install domain-check
Until then (or for any custom install), add this repo as a marketplace and install from there:
/plugin marketplace add PleasePrompto/domain-check-skill
/plugin install domain-check@domain-check-skill
gemini extensions install https://github.com/PleasePrompto/domain-check-skillThe repo is tagged with the gemini-cli-extension topic, so it appears in the Gemini Extensions Gallery automatically after Google's daily crawl.
Codex doesn't have an official skill marketplace yet. Clone the repo and copy just the skill folder into your agent's skills directory:
git clone https://github.com/PleasePrompto/domain-check-skill.git /tmp/dc
cp -r /tmp/dc/skills/domain-check ~/.agents/skills/domain-check # Codex CLI
cp -r /tmp/dc/skills/domain-check ~/.config/opencode/skills/ # OpenCode
rm -rf /tmp/dcTo pin the skill to a single repository so the whole team gets it:
git submodule add https://github.com/PleasePrompto/domain-check-skill.git .claude/plugins/domain-checkOnce installed, just talk to your agent. Triggers it recognises (English + German):
- "is X.com free?" / "ist X.de frei?"
- "check this domain" / "domain prüfen"
- "bulk domain check for these names"
- "SSL cert of X" / "what IP does X resolve to?"
- "suggest names for an AI phone-bot startup"
Or run the script directly from the skill directory:
cd skills/domain-check
python3 scripts/domain_check.py check example.com
python3 scripts/domain_check.py bulk example.com example.org example.net
python3 scripts/domain_check.py ssl example.com
python3 scripts/domain_check.py resolve https://example.com/path
python3 scripts/domain_check.py suggest graph --use-case ai_tool --count 20 --check| Command | Purpose |
|---|---|
check <domain> |
Single-domain check, JSON output with full evidence |
bulk <d1> <d2> … |
Up to 8 in parallel; supports --file, --stdin, --format=ndjson|json|table |
ssl <hostname> [--port 443] |
TLS-only inspection: issuer, SAN, validity, fingerprint, effective IP |
resolve <url|host> |
Hostname → IPv4 + IPv6 + reverse DNS for the first 3 IPs |
suggest <seed> --use-case <type> |
Generate scored, buyable domain candidates |
score <name> |
Heuristic score breakdown for a single bare name |
Run any command with --help for full flags.
Every check fans out asynchronously to five sources at once:
┌──────────────────┐
│ tld_classifier │
│ GTLD / GDPR / │
│ OPEN / UNKNOWN │
└────────┬─────────┘
│
┌──────────────────┬───────────────┼──────────────────┬──────────────────┐
▼ ▼ ▼ ▼ ▼
┌─────────┐ ┌───────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ RDAP │ │ WHOIS │ │ AuthDNS │ │ DNS A/ │ │ TLS │
│ (ICANN) │ │ (port 43) │ │ (NS) │ │ AAAA │ │ Cert │
└────┬────┘ └─────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │ │ │
└──────────────────┴──────────────┴─────────────────┴──────────────────┘
▼
┌──────────────────┐
│ verdict │
│ Available / │
│ Taken / … │
│ + confidence │
└──────────────────┘
Whether a domain is free or taken depends on which sources are authoritative for that TLD:
- gTLDs (
.com,.net,.io,.ai,.app,.pro,.club, …) — RDAP is mandatory under ICANN. RDAPno-object= 100% available. - GDPR ccTLDs (
.de,.eu,.at,.ch,.es,.li, …) — registry redacts RDAP/WHOIS. An authoritative NS lookup againsta.nic.de/x.dns.eu/ etc. yields a binary answer: NS records = registered, NXDOMAIN = available. - Unknown / reseller TLDs — WHOIS server is discovered live via
whois.iana.organd cached. If only disclaimers come back (no domain or registrar fields), the domain is treated heuristically as available.
- IDN domains (
münchen.de) — auto-converted to Punycode (xn--mnchen-3ya.de) - GDPR TLDs without expiry —
expiration_date: nullplus anexpiration_noteexplaining why (correct behaviour, not a bug) .ch/.li/.es— registry WHOIS port 43 blocks anonymous IPs; the authoritative DNS NS lookup is the primary source- Rate limiting (DENIC, AFNIC, SIDN) — bulk concurrency capped at 8; HTTP 429 triggers a single backoff retry
- IDNA failures — invalid IDN inputs fall back to lowercase ASCII (no crash)
The skill doubles as a naming assistant. Ask "suggest names for an AI phone-bot startup" and it:
- Reads
skills/domain-check/references/naming_guide.md— a guide covering length sweet spots, phonetics, naming patterns, TLD strategy, LLM-citability, and a hard don't list. - Generates scored candidates via
_lib/naming.py(length, syllables, plosive starts, alliteration, trademark / typo-squat checks). - Optionally bulk-checks the top N for real-world availability — so you only see names you can actually buy.
python3 scripts/domain_check.py suggest cloud --use-case indie_saas --check --check-top 5Supported use cases: tech_startup, ai_tool, dach_service, indie_saas, creative, developer, ecommerce_de, consumer_app, open_source, agency_dach.
domain-check-skill/
├── README.md # You are here
├── LICENSE
├── images/ # Screenshots used in this README
├── .claude-plugin/plugin.json # Claude Code plugin manifest
├── gemini-extension.json # Gemini CLI extension manifest
└── skills/
└── domain-check/ # The actual skill
├── SKILL.md # Agent entry point (frontmatter + instructions)
├── references/
│ └── naming_guide.md # How to invent a great name
└── scripts/
├── domain_check.py # CLI entry, argparse subcommands
└── _lib/ # Importable Python package
├── tld_classifier.py # TLD → GTLD_FULL / CCTLD_DSGVO / CCTLD_OPEN / UNKNOWN
├── rdap.py # RDAP client + IANA bootstrap cache (24 h)
├── whois_client.py # WHOIS socket + 30+ TLD patterns + IANA fallback
├── auth_dns.py # Native UDP DNS resolver (RFC 1035)
├── presence.py # DNS A/AAAA, HTTP/HTTPS, TLS cert with CN/SAN match
├── verdict.py # Decision tree → Available/Taken + confidence
├── orchestrator.py # async fan-out + final report assembly
└── naming.py # Heuristic candidate scorer + generator patterns
Other skills can import the library directly:
from _lib.orchestrator import check_domain
report = await check_domain("example.com")Zero install, zero dependencies, zero config. The entire skill runs on the Python ≥ 3.11 standard library — asyncio, socket, ssl, urllib, argparse, etc. The minimum version is required for dict | None syntax and asyncio.to_thread.
If you run an exotic Python build without the SSL module, only the ssl subcommand fails — everything else still works.
| Platform | Status | Notes |
|---|---|---|
| Linux | Tested | Primary dev platform |
| macOS | Tested | Same commands |
| Windows | Tested | Use python instead of python3 if needed |
| WSL2 | Tested | Treat as Linux |
| Docker | Works | python:3.11-slim is enough |
- Single check: typically 2–4 s (all five sources run concurrently)
- Bulk: 30 domains in ~10–15 s (concurrency 8, each domain again fans out per source)
- Cache hits: IANA RDAP bootstrap cached 24 h; WHOIS-server discovery cached persistently in temp dir
This skill follows the Agent Skills open standard. The same SKILL.md works in any compliant tool:
- Claude Code (Anthropic) — first-class
- Codex CLI (OpenAI) — first-class
- Gemini CLI (Google) — first-class
- OpenCode — first-class
- Cursor, Cline, Windsurf, GitHub Copilot (via VS Code) — community / partial
The skill is intentionally written to the lowest common denominator of the standard — only name and description in the frontmatter, all logic in plain Markdown plus Python scripts.
git clone https://github.com/PleasePrompto/domain-check-skill.git
cd domain-check-skill/skills/domain-check
python3 scripts/domain_check.py check example.com
python3 scripts/domain_check.py suggest lumen --use-case ai_tool --check --check-top 10There's no test suite yet — contributions welcome.
- Add the TLD to
_lib/tld_classifier.pyin the right bucket (GTLD_FULL,CCTLD_DSGVO,CCTLD_OPEN). - If it has a quirky WHOIS format, add a parser pattern in
_lib/whois_client.py. - If it's a GDPR ccTLD, the
auth_dns.pyresolver should already handle it — just verify the registry NS list.
Edit _lib/naming.py — patterns are simple Python functions returning candidate strings. The scoring heuristics live in the same file.
PRs welcome. Please:
- Open an issue first for non-trivial changes.
- Keep the zero-dependency rule — no
pip installever. - Keep the cross-platform rule — no shell-outs to
whois/dig/host(those aren't on Windows). - Run
python3 scripts/domain_check.py check <a-bunch-of-tlds>fromskills/domain-check/before submitting.
MIT — see LICENSE.
- Anthropic for the Agent Skills open standard
- IANA for the public RDAP bootstrap registry
- DENIC, EURid, SWITCH, AFNIC, SIDN — and every ccTLD registry that still answers authoritative NS queries truthfully when GDPR forces them to redact everything else