Use custom servers, pacing, and caching

Every advanced flag for reaching your own servers, going easier on a large sweep, and reusing answers inside one long-running session.

Prerequisites

• reserve installed. See Install reserve.
• Familiarity with a basic check. See Check whether a domain name is available.

Your own structured-service list

reserve example --registry-servers mine.json

{ "services": [[["io"], ["https://published.example/"]]] }

Your own text-service list

reserve example --text-servers mine.json

{
  "servers": {
    "com": {
      "host": "whois.mine.example",
      "available_phrase": "nothing here"
    }
  }
}

available_phrase is optional.

Overlay vs. replace

By default a supplied list overlays the built-in one: your entries win for the extensions they name, and everything else keeps working.

reserve example --text-servers mine.json --servers-replace

Control the IANA referral

When nothing already known answers, reserve asks IANA who serves that extension today, which repairs a built-in host that's gone stale. That lookup is cached per extension for the run.

$ reserve some-new-zone.example --no-referral
 
   DOMAIN                 STATUS   SOURCE    TIME  NOTE
?  some-new-zone.example  UNKNOWN          1632ms  no registry service
 
0 available  0 taken  1 unknown   (1 checked)
unknown means no registry would answer, never that the name is free

Useful for an offline run, or when you'd rather fail fast than wait on it.

Slow a large sweep down

A sweep across hundreds of extensions can hammer a small number of servers, since one operator often answers for hundreds of extensions from a single endpoint. reserve paces itself per registry host, never per extension.

$ reserve example -g everything --cautious
 
checking 40 of 272  example.shop 1s
 
   DOMAIN       STATUS     SOURCE      TIME  NOTE
+  example.com  AVAILABLE  registry   842ms
...

reserve example -g everything --cautious --rate 1 --per-registry 1

Reuse answers within one run

A name repeated in the input (typed twice, or given once as an argument and once inside --names-from) is asked once automatically, with the answer copied to every row that named it. This never crosses separate runs and never touches an available verdict.

$ reserve example --interactive --cache-ttl 300
# ... first check ...
   DOMAIN       STATUS  SOURCE      TIME  NOTE
-  example.com  TAKEN   registry  1104ms
 
# ... same check again inside the same picker session, within 300s ...
   DOMAIN       STATUS  SOURCE      TIME  NOTE
-  example.com  TAKEN   registry  1104ms  cached

Typing --cache-ttl alone on the command line runs once and exits. It's an instruction flag like any other, so it skips the picker the same way --tld or --group would. Pair it with --interactive to keep the picker open, or set the cache window from the picker's own settings screen (o) instead.

Result

A supplied server list, a slower pace, or a cache window changes how reserve reaches the network, but never changes the shape of the result table: you still get the same DOMAIN STATUS SOURCE TIME NOTE columns. An available answer is never served from cache, because a name that just became free is exactly the change this tool exists to catch.