AI Username Generator

Generate brand-safe, tone-specific username ideas with an LLM, then verify availability across GitHub, X, Instagram, Threads, TikTok, Twitch, and YouTube in a single run. You get a ranked shortlist with a per-platform available / taken / unknown verdict, confidence scores, and naming-quality signals — so you can pick a handle that fits your brand and is actually free where you need it.

Built for founders naming a startup, creators picking a public handle, and developers who want one consistent identity across platforms — without checking half a dozen sites by hand.

• Generate + verify + rank in one run — more than an LLM prompt, more than an availability checker.
• Fast: ≈8s for a typical 10 names × 2 platforms run (large 20 × 4 runs take ~17s).
• Low cost: ~$0.08 for a typical 10 names × 4 platforms run ($2.00 / 1,000 checks); a max 20 × 7 run costs ~$0.28.
• No logins, no browser automation: unauthenticated, point-in-time checks with confidence scores; ambiguous responses are reported honestly as unknown.
• Agent-ready: flat JSON dataset plus a grouped summary record — wires into MCP, Make, Zapier, and n8n.

---

Quick start

1. Create a free Apify account (or sign in).
2. Open this Actor's page and go to the Input tab.
3. Add at least one keywords entry — everything else has a sensible default.
4. Click Start and wait a few seconds.
5. Open the Storage tab to view the ranked dataset, or read the OUTPUT key-value record for the single best pick.

---

What this Actor does

1. Generates up to 20 candidates from your keywords, brand/personal name, niche, and tone using a cost-optimized LLM pipeline (DeepSeek primary, GPT-4o-mini fallback via OpenRouter).
2. Filters them deterministically — profanity, homoglyph/leetspeak lookalikes (d3vil is caught by banning devil), your custom banned words, and each platform's handle rules (length, allowed characters).
3. Verifies availability with unauthenticated HTTP checks over datacenter proxies — no browser automation, no logins, no credentials sent to any platform.
4. Ranks the survivors by naming quality, adjusted for real availability, and writes a flat dataset (one row per username × platform) plus a grouped OUTPUT summary that names the single best pick.

---

Why use it

• Get names, not just availability. The LLM proposes on-brand candidates in the tone you choose — you are not feeding it your own list.
• Pick a name that is free everywhere. The grouped summary names the single candidate open across all the platforms you care about.
• Stop checking handles by hand. One run replaces opening seven sites in seven tabs for every idea.

---

Supported platforms

Platform	What is checked	Reliability
GitHub	Profile 404 vs 200	High — most reliable check
Threads	WebFinger discovery lookup	High
Instagram	Profile page <title> signal	Medium-high
Twitch	Channel existence	High
YouTube	Handle / channel exists	High
TikTok	Embedded profile JSON	Reliable for taken; never reports available (see below)
X (formerly Twitter)	Profile reachability	Variable — 30–50% return unknown due to login walls; optional, not in the default platform list

Two platforms behave specially, by design. X often returns unknown (login wall — opt in via platforms and expect a higher unknown rate), and TikTok never returns available (anti-enumeration — it only emits taken or unknown). Both are deliberate honesty measures, not bugs; the ranking step downweights any unknown. Full explanations in Known limitations and the FAQ.

---

Input

Only keywords is required. Everything else has a sensible default, so the smallest valid input is a single keyword.

Field	Type	Default	Description
keywords	string[]	— (required)	Seed words/themes to build names around, e.g. ["vault", "alpha"].
brandName	string	—	Existing brand whose fragments to weave in (e.g. BrandCraft → brandcrafthq).
personalName	string	—	Personal name for individual/creator handles (e.g. Ray → raybuilds).
niche	string	—	Industry/niche (e.g. fintech, indie gaming) — drives naming conventions.
tone	enum	Professional	One of Professional, Minimal, Gamer, Creative.
platforms	string[]	["github"]	Any of github, threads, instagram, twitch, youtube, tiktok, x (lowercase; use x, not twitter). x is optional and not selected by default — see Supported platforms.
maxLength	integer	20	Max handle length (hard cap 30). Set ≤ 15 when targeting X; ≤ 24 when targeting TikTok.
bannedWords	string[]	[]	Words to exclude — matched after de-leeting, so d3vil is caught by banning devil.
count	integer	10	Candidates to generate (hard cap 20 per run).
inputMode	enum	full	full = generate and verify (billable). generate_only = generate without checks (free, for brainstorming).

Example input — founder / startup

{
    "keywords": ["launch", "build"],
    "niche": "developer tools",
    "tone": "Professional",
    "platforms": ["github", "x"],
    "count": 10
}

Example input — creator / gamer

{
    "keywords": ["stream", "play"],
    "tone": "Gamer",
    "platforms": ["twitch", "youtube"],
    "count": 10
}

---

Output

The Actor writes to two places:

1. Dataset — one row per candidate × selected platform (10 names × 2 platforms = up to 20 rows). Up to 20 candidates per run; the row count is not capped at 20.
2. Key-value store OUTPUT — a grouped per-name summary with the top pick and a machine-readable chargeable / degraded verdict. This is the record AI agents should read first.

Dataset fields

Field	Meaning
username	The generated candidate.
normalizedUsername	Lowercased/stripped form used for checks and cache keys.
platform	github / threads / instagram / twitch / youtube / tiktok / x.
status	available, taken, invalid, unknown, rate_limited, or unverified (generate-only).
confidence	0–100 verification certainty (cache hit 100, HTTP-verified 90) — not naming quality.
reasonCode	Stable machine-readable code to branch on: PROFILE_NOT_FOUND, PROFILE_EXISTS, LOGIN_WALL, REQUEST_TIMEOUT, RATE_LIMITED, AMBIGUOUS_SIGNAL, CHECK_FAILED, RULES_INVALID, UNVERIFIED_GENERATE_ONLY.
reason	Human-readable, platform-aware explanation of the verdict.
debug	Nested low-level detail { verificationMethod, httpStatus?, timedOut? } (not a CSV column).
verification_method	Deprecated (kept for back-compat; use reasonCode / debug.verificationMethod). How the status was found, e.g. http_404, http_200, cache_hit, none.
rankingScore	0–100 naming quality, adjusted for availability.
rankingRationale	Short human-readable reason for the rank.
statusReason	Deprecated (kept for back-compat; use reason). Why a status was assigned (e.g. login wall → unknown).
brandFit / readability / memorability	0–100 LLM naming scores.
isHighConfidence	true when confidence ≥ 80 and status is available/taken.
platformRulesValid	Passed that platform's handle rules.
runId	Apify run ID for traceability.

Example output row

{
    "username": "buildvaulthq",
    "normalizedUsername": "buildvaulthq",
    "platform": "github",
    "status": "available",
    "confidence": 90,
    "reasonCode": "PROFILE_NOT_FOUND",
    "reason": "GitHub profile not found — the handle appears available.",
    "debug": { "verificationMethod": "http_404", "httpStatus": 404 },
    "verification_method": "http_404",
    "rankingScore": 82,
    "rankingRationale": "Strong brand fit, available on GitHub, easy to read",
    "statusReason": "Verified via http_404",
    "brandFit": 88,
    "readability": 80,
    "memorability": 78,
    "isHighConfidence": true,
    "platformRulesValid": true,
    "runId": "abc123"
}

---

How availability checking works

• Unauthenticated HTTP only. The Actor requests public profile/channel URLs and maps the HTTP response to a status. No credentials are ever sent to GitHub, Threads, Instagram, Twitch, YouTube, TikTok, or X, and raw external HTML is never stored in your dataset or logs.
• Datacenter proxies. Checks run through Apify datacenter proxies with session rotation — no residential proxies, keeping runs cheap and fast.
• No browser automation. Ambiguous responses degrade to unknown rather than being force-resolved with a headless browser. This is why X (which gates profiles behind a login wall) frequently returns unknown.
• 10-second pipeline deadline. A global deadline flips any still-pending checks to unknown and proceeds to scoring, so a slow platform can never blow the run-time budget.
• Caching. Confirmed-taken handles are cached in a key-value store, so repeat runs over trending names skip redundant proxy calls.

---

Run modes & pricing

This Actor uses pay-per-event pricing at $2.00 / 1,000 checks. You choose the work per run with inputMode:

inputMode	Work performed	Billing
full (default)	Generate + Tier-1 filter + availability verification	Charged per verified result at $2.00 / 1,000 checks
generate_only	Generate + Tier-1 filter only (rows come back unverified)	Free — no charge. Ideal for brainstorming before committing

Charged per verified result ($0.002/row) when the run succeeds and at least one platform was verified. A typical run (10 names × 4 platforms) costs ~$0.08. Runs that fail before producing output, or that come back degraded (zero platforms verifiable — all unknown/rate_limited), are not charged. generate_only runs are always free. There is no separate user tier and no reduced name cap — every mode supports up to 20 names.

---

Usage via API

Run the Actor programmatically with the Apify API client. Supply your Apify API token.

Python

$pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "keywords": ["launch", "build"],
    "tone": "Professional",
    "platforms": ["github", "x"],
    "count": 10,
    "inputMode": "full",
}

# Start the run and wait for it to finish
run = client.actor("protocol/username-generator-checker").call(run_input=run_input)

# Read the per-row dataset
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["username"], item["platform"], item["status"], item["rankingScore"])

# Read the grouped summary (best pick + chargeable/degraded verdict)
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")
print(summary["value"])

JavaScript / TypeScript

$npm install apify-client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('protocol/username-generator-checker').call({
    keywords: ['stream', 'play'],
    tone: 'Gamer',
    platforms: ['twitch', 'youtube'],
    count: 10,
    inputMode: 'full',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((i) => ({ name: i.username, platform: i.platform, status: i.status })));

cURL

curl -X POST "https://api.apify.com/v2/acts/protocol~username-generator-checker/run-sync-get-dataset-items?token=<YOUR_APIFY_API_TOKEN>" \
  -H 'Content-Type: application/json' \
  -d '{ "keywords": ["vault", "alpha"], "platforms": ["github"], "count": 5 }'

---

Use with AI agents (MCP)

The Actor is built to be driven by AI agents. The INPUT_SCHEMA.json exposes typed fields with enum dropdowns and defaults, so an MCP client (e.g. Claude Desktop via the Apify MCP Server) can call it with minimal prompting. Agents should read the grouped OUTPUT record — it carries the single best candidate and a machine-readable chargeable/degraded verdict, so the agent does not have to reduce the flat dataset itself. Invalid input returns a structured error code rather than a silent failure (see Run-level error codes).

Connect via the Apify MCP Server with a client config like:

{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=protocol/username-generator-checker",
                "--header",
                "Authorization: Bearer <YOUR_APIFY_API_TOKEN>"
            ]
        }
    }
}

---

Run-level error codes

Most failures are reported per-row via reasonCode (see Dataset fields). A small set of run-level codes cover failures before any row can be produced — for example, invalid top-level input. The Actor always returns one of these rather than failing silently:

Code	Meaning
ERR_INVALID_INPUT	Input failed schema validation (e.g. missing keywords, count > 20).
ERR_MISSING_API_KEY	The Actor's LLM provider credential is not configured (operator-side).
ERR_LLM_PIPELINE_FAILED	Both the primary and fallback LLM engines failed or timed out.
ERR_ALL_PLATFORMS_RATE_LIMITED	Every selected platform returned a rate-limit response — run degraded.
ERR_OUTPUT_SCHEMA_VIOLATION	An internal output failed schema validation before being written.

---

FAQ

Why does X return unknown so often, and why isn't it checked by default? X gates many profiles behind a login wall. Rather than scrape past it with a headless browser, the Actor honestly reports unknown (30–50% of X checks). Because of this, X is not included in the default platforms list — add x explicitly when you need it, and treat unknown as "could not confirm," not "taken."

Why does TikTok never return available? TikTok intentionally returns the same status code whether a handle was never registered or belongs to a banned account — there is no unauthenticated way to distinguish the two. To avoid false positives, this Actor's TikTok adapter only ever reports taken or unknown, never available. Expect most genuinely free TikTok handles to come back unknown; this is a deliberate platform anti-enumeration measure, not a bug, and the ranking step already downweights candidates with any unknown result.

Can a name marked available be taken later? Yes. Results are a point-in-time snapshot. A handle can be claimed by someone else before you register it, and available may reflect a recently-released handle still in a platform grace window. Re-confirm before relying on it.

Will the same input always return the same names? No. LLM generation is non-deterministic — the same input can produce different candidates across runs. The availability verdicts for a given handle are deterministic.

How many names can I generate per run? Up to 20, in any mode. Larger batches require multiple runs.

How do I brainstorm cheaply before committing? Run with inputMode: "generate_only". It generates and filters names without availability checks (status unverified) and is free. Switch to full when you want verified results.

Is my input data sent anywhere? Keyword and name inputs are sent to a third-party LLM provider (via OpenRouter) to generate candidates. See Data & privacy below.

Can I connect this to Zapier, Make, n8n, or a webhook? Yes. The Actor works with any tool that can call the Apify API — including Make, Zapier, and n8n integrations and Apify webhooks (e.g. notify on run success). See Usage via API for direct API/SDK calls, or Use with AI agents (MCP) for MCP clients.

---

Known limitations

Limitation	What to expect
X unknown rate, optional	30–50% of X checks return unknown due to login walls — expected, not a bug. X is not in the default platform list; opt in explicitly via platforms.
TikTok never reports available	TikTok collapses "never registered" and "banned" into one ambiguous code — the adapter only ever emits taken or unknown, so expect a near-100% unknown rate on free handles. Not a bug.
No browser automation	Ambiguous responses degrade to unknown rather than being force-resolved.
Point-in-time availability	A handle marked available may be claimed before you register it. Re-confirm before relying.
Grace-window handles	available may reflect a recently-released handle still in a platform grace window.
Non-deterministic generation	The same input may produce different candidates on different runs.
Max 20 names per run	Hard cap; larger batches require multiple runs.

---

Data & privacy

• Keyword and name inputs are sent to a third-party LLM provider (via OpenRouter) to generate candidates. Do not include personal data you do not want shared with an LLM provider. personalName-derived outputs persist in the run's dataset and exports.
• Availability checks are unauthenticated — no credentials are sent to any platform, and no raw external HTML is stored in your dataset or logs.
• Data retention: datasets are retained per your Apify account settings. Delete the run to erase its outputs.

---

Support

Found a bug or want a platform added? Open an issue on the Actor's Issues tab in the Apify Console. Feature requests (preset naming modes, availability monitoring/watchlist, bulk validation) are tracked on the roadmap.