Checking ccTLD availability without trusting one source (and what .si actually sells for)

alhag mousab — Sat, 17 Oct 2026 14:17:10 +0000

Every "is this domain available" check you have ever run is a wrapper around someone else's cache. For .com that's usually fine — dozens of systems cross-check each other. For a ccTLD it is not fine, and .si (Slovenia) is a good example: one letter away from .ai, a growing number of short names, and almost no tooling that looks at it.

I built a small free API around it, and the interesting part was not the code — it was realising how many ways a single-source availability check can lie to you.

Three ways availability data goes wrong

1. Stale cache. A registrar's "available" answer is often minutes to hours old. Someone registers the name in between and you find out at checkout.

2. Wildcard DNS. Some domains answer every query with an A record. A naive DNS check says "taken" for names that don't exist, or "free" for names that do.

3. Registry-only records. A name can exist at the registry with no nameservers at all — NXDOMAIN everywhere, still not yours to register. This is the trap that bites hardest, because DNS looks exactly like an unregistered name.

The fix is boring: check two independent systems and compare their answers instead of trusting either one.

Signal one — the registry

.si is run by ARNES. The registry record tells you existence, registrar, registration and expiry dates, and nameservers. That is the authoritative answer to "does this exist", and it is the only source that cannot be faked by DNS weirdness.

I exposed it as plain JSON (no key, no signup):

import json, urllib.request

def registry(name: str) -> dict:
    url = f"https://worthly.si/api/check.php?q={name}"
    with urllib.request.urlopen(url, timeout=10) as r:
        return json.load(r)

rec = registry("chauffeurs")

Real output, trimmed:

{
  "domain": "chauffeurs.si",
  "availability": "registered",
  "note": "Registered at the .si registry (ARNES).",
  "registrar": "Spaceship, Inc.",
  "registered": "2026-10-08",
  "expires": "2027-10-08",
  "nameservers": ["launch2.spaceship.net", "launch1.spaceship.net"]
}

Notice what you get for free: the name was registered nine days ago and parked on a registrar's launch nameservers. That is a domain someone bought to flip, and no availability check would have told you that.

Signal two — DNS, asked carefully

DNS answers a different question: is this name actually in use. The part people get wrong is treating every failure as "free".

import dns.resolver

def dns_view(name: str) -> str:
    for qtype in ("NS", "SOA"):
        try:
            dns.resolver.resolve(name, qtype, lifetime=5)
            return f"{qtype} present"
        except dns.resolver.NXDOMAIN:
            return "NXDOMAIN"          # name does not exist
        except dns.resolver.NoAnswer:
            continue                   # exists, no record of this type
        except dns.resolver.NoNameservers:
            return "SERVFAIL/lame"     # registry knows it, DNS does not answer
        except dns.resolver.Timeout:
            return "timeout"           # inconclusive — do not call it free
    return "no NS/SOA"

NXDOMAIN on both NS and SOA is the only DNS answer that supports "unregistered". SERVFAIL, NoNameservers and timeouts are inconclusive — and a name that is NXDOMAIN while the registry says "registered" is a registry-only name, not an opportunity.

Two resolvers, compared, is enough. If resolver A says NXDOMAIN and resolver B returns records, you are probably looking at a broken delegation or a wildcard — not a free domain.

What `.si` names actually sell for

This is where ccTLDs are usually a black box: no comps, so buyers price on vibes and sellers price on hope. The sales index behind the API currently holds 299 recorded .si sales:

median $2,678
mean $4,473
highest $50,000

The gap between median and mean is the whole story: a handful of five-figure deals drag the average up, and if you price against the average you will sit on names for a year. Median is what a typical .si actually clears at.

Paired with an appraisal on the same name, the shape is visible. chauffeurs.si, a dictionary word parked nine days ago:

{
  "method": "appraisal v2",
  "domain": "chauffeurs.si",
  "value": { "low": 910, "mid": 1660, "high": 3480, "currency": "USD", "confidence": "medium" },
  "signals": { "category": "dictionary", "length": 10, "dictionary": true, "hyphen": false, "digit": false }
}

confidence: medium matters more than the numbers. A dictionary word with a real market gets a range; a random string gets nothing useful, and a tool that pretends otherwise is selling you a number, not information.

def appraise(name: str) -> dict:
    url = f"https://worthly.si/api/appraise.php?name={name}"
    with urllib.request.urlopen(url, timeout=10) as r:
        return json.load(r)

def recent_sales(limit: int = 25) -> dict:
    url = f"https://worthly.si/api/sales.php?limit={limit}"
    with urllib.request.urlopen(url, timeout=10) as r:
        return json.load(r)

Both are free and keyless. The sales endpoint labels each row: venue-reported deals are marked reported, venue-confirmed ones verified, and asking prices are excluded entirely — a distinction most "domain sold for $X" lists quietly ignore.

Where this breaks

Thin comps. 299 sales is a real dataset, not a thick one. One unusual deal moves the median.
Parked ≠ end user. A registrar-parked name and a company-owned name look identical in the registry.
IDNs and non-.si. Different registry, different answer; do not extrapolate.
Availability is not value. A free name and a valuable name are unrelated questions, and tools that merge them into one "score" are guessing.

If you are checking .si names, the useful workflow is: registry record first, DNS second, comps third, and treat anything inconclusive as unknown rather than free. The API is at worthly.si/api — attribution appreciated, and happy to hear where the appraisal method is wrong.