dotld , Domain Availability & Pricing

intent

check domain name availability and real-time registration prices via the Dynadot API. use this skill when the user mentions domains, TLDs, domain registration, domain availability, or wants to find, check, or brainstorm domain names. runs the dotld CLI to query live pricing and availability across 9 popular TLDs (com, net, org, io, ai, co, app, dev, sh) or specific domains you provide.

inputs

external connection: Dynadot API

• endpoint: Dynadot production API (https://www.dynadot.com/api)
• auth: API key required
• key resolution order:
  1. --dynadot-key <key> flag (auto-saves to ~/.config/dotld/config.json)
  2. DYNADOT_API_PRODUCTION_KEY environment variable
  3. saved config at ~/.config/dotld/config.json
• get key at https://www.dynadot.com/account/domain/setting/api.html
• rate limits: standard Dynadot API rate limits apply (typically 100 requests per minute; check Dynadot docs for current limits)

required binaries

• dotld CLI installed and in PATH. if missing, install via:

  curl -fsSL https://raw.githubusercontent.com/tedstonne/dotld/main/scripts/install.sh | bash
  

parameters

• domain or keyword (string, required): exact domain (with dot) or keyword (no dot)
• --file (optional): read domains from file, one per line
• --json (optional): output structured JSON instead of tree table
• --timeout (optional): request timeout, default 10s, e.g. 5s, 500ms
• --currency USD (optional): only USD supported in v1, default USD
• --dynadot-key (optional): provide API key inline, overrides env

procedure

1. verify dotld is installed

   • input: system PATH
   • command: which dotld
   • output: path to dotld binary or error if missing
   • on failure: install dotld using curl script above, retry

2. verify Dynadot API key is set

   • input: environment variable DYNADOT_API_PRODUCTION_KEY, config file ~/.config/dotld/config.json, or --dynadot-key flag
   • command: dotld --help will show key status
   • output: confirmation that key is loaded (or error message with link to key page)
   • on failure: stop and instruct user to set DYNADOT_API_PRODUCTION_KEY or pass --dynadot-key

3. parse user input

   • input: user's domain or keyword string
   • determine if input contains a dot (.) or not
   • output: classification of input type (exact domain vs keyword)

4. run exact domain lookup (if input contains dot)

   • input: full domain name, e.g. example.com
   • command: dotld example.com
   • output: single line with domain status and price (if available) and buy link (if available)
   • example outputs:
     • example.com · Taken (registered, unavailable)
     • example.com · $9.99 · https://www.dynadot.com/domain/search?domain=example.com&rscreg=github (available)

5. run keyword expansion (if input has no dot)

   • input: keyword, e.g. acme
   • command: dotld acme
   • output: tree table showing keyword checked across 9 default TLDs (com, net, org, io, ai, co, app, dev, sh)
   • example output:

     acme
     ├─ acme.com · Taken
     ├─ acme.net · Taken
     ├─ acme.io  · $39.99 · https://www.dynadot.com/domain/search?domain=acme.io&rscreg=github
     └─ acme.sh  · Taken
     

6. run batch lookup (if multiple inputs or --file flag)

   • input: multiple domains/keywords as arguments or file path
   • command: dotld domain1 domain2 domain3 OR dotld --file domains.txt
   • output: results for all domains in table or JSON format
   • note: each API call counts toward rate limit

7. convert to JSON if requested

   • input: --json flag set
   • command: dotld <domain> --json
   • output: structured JSON array with fields: domain, available (bool), price (USD), currency, buyUrl, cached (bool), quotedAt (ISO timestamp)
   • example:

     {
       "results": [
         {
           "domain": "example.com",
           "available": false,
           "price": null,
           "currency": "USD",
           "buyUrl": null,
           "cached": false,
           "quotedAt": "2026-02-21T00:00:00.000Z"
         }
       ]
     }
     

8. parse and present results to user

   • input: dotld output (table or JSON)
   • output: ranked list of available domains sorted by price (ascending), include buy links
   • note: all prices in USD, v1.0.7 only supports USD
   • suggest next steps: open buy link, check more TLDs, try name variations

decision points

• if input contains a dot: run exact domain lookup (step 4). if input has no dot, run keyword expansion across 9 TLDs (step 5).

• if Dynadot API key is missing: check in order: --dynadot-key flag, DYNADOT_API_PRODUCTION_KEY env var, ~/.config/dotld/config.json. if all are empty, exit with error message and link to https://www.dynadot.com/account/domain/setting/api.html. user must provide key before proceeding.

• if --file flag is provided: read domains from file (one per line) instead of command-line arguments. skip step 3 (parse single input), run batch lookup (step 6).

• if --json flag is provided: output structured JSON (step 7) instead of human-readable tree table. useful for programmatic parsing or downstream tools.

• if domain is available: display price (in USD), buy link, and encourage user to register. if domain is taken, move to next option or suggest variations.

• if result set is empty: (e.g., file with no valid domains, or network issue), exit gracefully with error message. do not proceed to step 8.

• if network timeout occurs: check --timeout parameter (default 10s). if user suspects slow network, increase timeout (e.g. --timeout 30s) and retry. if timeout persists after retry, suspect Dynadot API outage or user network issue.

• if rate limit is hit: Dynadot API will return 429 or rate-limit error. user must wait before retrying. batch requests should be staggered or split across multiple runs. dotld may cache results (see cached field in JSON output).

• if API key is invalid or expired: Dynadot API returns 401 or 403. user must refresh key at https://www.dynadot.com/account/domain/setting/api.html and update DYNADOT_API_PRODUCTION_KEY env or --dynadot-key flag.

output contract

human-readable table output (default)

• format: tree structure (using box-drawing characters) or flat list
• fields per domain: domain name, status (Taken or available), price (if available, in USD), buy link (if available)
• sorted by: availability (available first), then by price (ascending)
• location: stdout

JSON structured output (--json flag)

• format: valid JSON object with top-level "results" array
• fields per domain: domain (string), available (bool), price (number or null), currency (string, always USD in v1), buyUrl (string or null), cached (bool), quotedAt (ISO 8601 timestamp)
• location: stdout
• parseable by standard JSON tools and downstream scripts

error output

• format: plain text error message to stderr
• example: "error: Dynadot API key not found. set DYNADOT_API_PRODUCTION_KEY or use --dynadot-key flag. get a key at https://www.dynadot.com/account/domain/setting/api.html"
• exit code: non-zero on error, 0 on success

outcome signal

• user sees available domains with prices: skill worked. user can click buy links or note domain names for registration.
• user sees "Taken" for all results: skill worked, but no availability. suggest variations or different TLDs.
• JSON output is valid and parseable: skill worked for programmatic use. downstream tools can extract available domains and prices.
• no error messages and exit code is 0: skill completed successfully.
• user can proceed to register: buy links point to Dynadot domain registration page, ready to purchase.