fortunto2/solo-factory/domain

domain — is this name actually free?

A name is not available because a domain is free. It has to be clear on every surface the product will live on: the zones you will buy, the App Store (where names are unique and a collision blocks release), Google Play, the code host, and the trademark register. Checking only the domain is how people buy a domain for a name the App Store will later refuse.

Output: a table of candidates against those surfaces, and a recommendation that says what the runner-up trades away.

Workflow

1. List candidates. 6–12 names, including the user's own suggestions verbatim — they know

their brand voice, and the job here is verification, not taste.

1. Zones. RDAP first, whois for ccTLDs — RDAP lies about them, see Gotchas.
2. App Store. Exact-name search. Do this before pricing domains: a blocked store name

makes the domain worthless.

1. Code host. GitHub is a reliable signal; most social sites are not.
2. Whatever sits on a taken `.com`. Fetch its title. Parked junk, "Coming Soon" and a live

business in the same category are three different risks, not one.

1. Trademark. Search the exact name plus "trademark". Flag holders who defend aggressively

in that category.

1. Recommend one, with the trade-off stated.

Zones

# RDAP: 404 = free, 200 = registered. -L is required — rdap.org answers 302 first.
avail() { [ "$(curl -sL -o /dev/null -w '%{http_code}' --max-time 20 \
  "https://rdap.org/domain/$1")" = "404" ] && echo FREE || echo taken; }
 
# ccTLDs (.co .io .me .ai …) — RDAP usually has no server for them, so whois is the source.
avail_cc() { whois "$1" 2>/dev/null | grep -qiE "no match|not found|no data found" \
  && echo FREE || echo taken; }

Run the check against a domain known to be registered (google.com, google.co) before trusting a batch. That one control call is what separates a report from a guess.

App Store

curl -s "https://itunes.apple.com/search?term=NAME&entity=software&limit=25&country=us" \
  | python3 -c "
import json,sys,re
n='NAME'.lower()
r=json.load(sys.stdin)['results']
hit=[a['trackName'] for a in r if n==re.sub(r'[^a-z0-9]','',a['trackName'].lower().split(':')[0])]
print('TAKEN: '+hit[0] if hit else 'free')"

Match the part before the colon — store names are Brand: Subtitle and the subtitle is marketing, not identity. On a hit, follow up with https://itunes.apple.com/lookup?id=<trackId>: an app with zero ratings and an untouched 1.0 is a name collision, not a market leader, and that difference changes the advice you give.

Code host

curl -s -o /dev/null -w "%{http_code}" https://github.com/NAME — 404 means free.

Gotchas

• RDAP returns 404 for entire ccTLD zones it has no server for. google.co reports 404, i.e.

"free". Every .co, .io or .me checked that way reads as available, and every one of those answers is worthless. Use whois there, and prove the method on a domain you know is taken.

• `curl` without `-L` against rdap.org returns 302 for everything, so free and taken look

identical.

• whois for `.app` and other Google Registry zones often returns nothing at all — and empty

output reads as "no match" to a careless grep, i.e. "free". RDAP works there; whois does not.

• A taken `.com` is three different situations. Fetch the <title>: a live business in the

same category kills the name in every zone; a parking page costs only that zone; "Coming Soon" means someone is building right now, which is the worst case — they will look like a copy of you, or you of them.

• Google Play's search page echoes the query string, so grepping its HTML for the name

matches the query itself and reports a collision that does not exist. Look for app cards.

• X and Instagram return 200 for handles that do not exist — they serve an app shell before

resolving the name. As availability checks they are noise. GitHub's 404 is honest.

• App Store names are unique per store. A free domain plus a taken store name means the

product cannot ship under that name. The store is the constraint that cannot be negotiated; check it first.

Don't

• Don't buy before the store check. The domain is the cheap, reversible part.
• Don't trust one method or one source. Two independent signals (RDAP + DNS NS, or whois +

the live site) cost seconds and catch every zone-wide false positive above.

• Don't put the mechanism in the name — *AI, *GPT, *Chain. It dates the brand to a

single year, and in trust-sensitive categories (health, legal, immigration, finance) it advertises that a machine decides, which is the opposite of what those buyers are looking for.

• Don't take a name whose `.com` runs a competitor, even when your zone is free. You will

feed their typo traffic forever and lose every trademark argument.

• Don't promise the outcome in the name in a regulated category — a brand that sounds like a

guarantee ("approved", "granted") invites both the regulator and the disappointed customer. Optimism is fine; a promise is not.

• Don't optimise only for English. Check how the word lands in the languages the product

actually sells in. A name that is a real word in each travels for free, and casual slang that reads as addressed to one gender quietly excludes half the market.