# Discord Username Checker \[CHEAP💰] | Tokenless | Brands (`ahmed_jasarevic/discord-username-checker`) Actor

Bulk-check up to 500 Discord usernames per run via the official signup endpoint — tokenless, no login, no captcha. Available / taken / invalid per handle with exact error codes.

- **URL**: https://apify.com/ahmed\_jasarevic/discord-username-checker.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Discord Username Checker — Bulk Availability in One Tokenless Call

Bulk-check up to **500 Discord usernames per run** for availability in a single call — using Discord's **official signup availability endpoint**, no login, no token, no captcha. Returns per-handle status (`available`, `taken`, `invalid`), specific diagnostics (e.g. `USERNAME_INVALID_CHARACTERS`), the exact requested vs. resolved handle, and a completed `OUTPUT` summary. Built for username acquisition research, brand protection and handle portfolio management.

### Main Use Cases

- **Brand protection** — check all your trademarks and brand-word handles at once; log validity endings for renewal decisions.
- **Username acquisition research** — find available handles for gamer tags, vanity handles and portfolio buying.
- **Handle portfolio management** — monitor a large list of your own handles in one scheduled run (validity ending, case resolution).
- **Social-launch planning** — reserve/claim planning for product names across Discord before release.

### How It Works

The actor calls Discord's **unauthenticated username-attempt endpoint** (the same one the signup form uses) with a clean session per handle. Each handle gets its own response: whether the username is available, taken, or invalid — plus the specific `errorCode` when Discord rejects it (invalid characters, taken, etc.). Results land one row per checked handle; a run-level summary (totals: available/taken/invalid, checked list) is written to the **OUTPUT** record in the key-value store.

### Check 500 Usernames in One Run — No Tokens, No Self-Bots

Discord name checkers that use **self-bots or user tokens violate Discord's Terms of Service** and burn tokens/accounts. This actor uses the public unauthenticated endpoint — the exact request the signup page makes — so one **API run checks up to 500 usernames** (pay-per-result billing). No Discord account, no token, no captcha solving.

### Detect Exact Reasons a Handle Is Unavailable

Beyond yes/no, each row carries the precise `errorCode` Discord returned (`USERNAME_INVALID_CHARACTERS`, `USERNAME_TOO_SHORT`, `USERNAME_TOO_LONG`, `USERNAME_TAKEN`, `USERNAME_INVALID_RATE_LIMIT`, `USERNAME_CLAIMED`, `USERNAME_ALREADY_CLAIMED`) — so you can distinguish handles that are taken from ones that are simply invalid or rate-limited, and retry precisely.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `usernames` | array | **Yes** | — | Handles to check, one per line — **up to 500 per run**. |
| `maxConcurrency` | integer | No | `15` | Parallel checks (1–50). Higher is faster but more likely to hit Discord rate limits. |
| `proxyConfiguration` | object | No | Apify residential | Leave the default (Apify **residential** proxy) on — unproxied requests get rate-limited and fail. |

### Example Input

```json
{
  "usernames": ["coolname", "my_brand-name", "john doe", "ab"],
  "maxConcurrency": 15
}
```

### Example Output

```json
{
  "status": 200,
  "requestedUsername": "my brand",
  "username": "my_brand",
  "isAvailable": true,
  "errorCode": "",
  "attempts": 5,
  "checkedAt": "2026-09-23T09:41:05.943Z"
}
```

#### Taken / invalid uses the same shape

`isAvailable: false` with the matching `errorCode` (e.g. `USERNAME_TAKEN` or `USERNAME_INVALID_CHARACTERS`) and the resolved `username` Discord actually evaluated against.

### Verify Availability With Attempts & Status Diagnostics

`status` echoes the HTTP response (200 ok, 429 rate-limited, etc.), `attempts` tells you how many tries a handle took, and `checkedAt` timestamps every check — so reruns can dedupe, and rate-limit noise is visible in data, not hidden in logs.

### Integrations & Automation

- **Apify API** — pipe results into a handle-portfolio ledger or brand-watch alerting.
- **Scheduling** — daily validity-ending watchers, weekly brand-handle sweeps.
- **Webhooks** — notify when a monitored handle flips to `available`.
- **Export** — JSON, CSV, Excel.

*Recommended schedule:* daily for validity-ending alerts and brand monitoring; the JSON body in a scheduled task makes 500-handle sweeps a one-click routine.

### Related Actors

- [Discord Username Checker](https://apify.com/maged120/discord-username-checker) — the largest checker on the Store (4,300+ users), per-check billing.
- [Discord Username Checker](https://apify.com/dev00/discord-username-checker) — single-username availability checks with retries.
- [Discord Username Checker](https://apify.com/khadinakbar/discord-username-checker) — availability + plus-suffix removal checks.
- [Discord Member Scraper](https://apify.com/jungle_synthesizer/discord-member-scraper) — extract members from public channels and servers.

### FAQ

#### Why use this actor instead of a token/self-bot checker?

Token-based checkers (self-bots, user tokens) **violate Discord's Terms of Service** and get accounts banned; many open-source "checkers" on GitHub require tokens or captcha-solving. This actor uses Discord's official unauthenticated signup endpoint — tokenless by design, safe for accounts, and one run covers up to 500 handles.

#### What are alternatives to this actor / Discord username checking?

- [maged120/discord-username-checker](https://apify.com/maged120/discord-username-checker) — $0.01/result.
- [dev00/discord-username-checker](https://apify.com/dev00/discord-username-checker) — $0.005/check, single-handle.
- [khadinakbar/discord-username-checker](https://apify.com/khadinakbar/discord-username-checker) — $0.008/handle.
- GitHub open-source checkers — token-based, ToS-violating, account-burning.

#### How do I check a whole list of handles daily?

Create a task with your full list (≤500) as `usernames`, schedule it daily — the OUTPUT summary only marks totals; you diff dataset rows across days to see availability flips.

#### Why did a handle I know is available come back `invalid`?

Discord rejects handles violating its rules with specific codes — read the `errorCode`: spacing is resolved (e.g. `my brand` → `my_brand`), but unsupported characters or reserved words return e.g. `USERNAME_INVALID_CHARACTERS`.

#### How is availability checked without logging in?

Exactly like the public signup page: the actor POSTs the handle to Discord's unauthenticated availability endpoint with a fresh session and reads the JSON decision — the same yes/no the browser gets.

### SEO Keywords

discord username checker, discord username availability, discord handle sniper, bulk discord name check, discord username taken, discord name validation, discord brand protection, discord handle monitoring, tokenless discord checker, discord username api, discord unique username, discord vanity handle, discord signup availability, discord username error codes

### For AI Agents & LLM Apps

- **Purpose:** given an array of `usernames` (≤500), returns one row per handle with `isAvailable`, Discord's `errorCode` when rejected, the resolved username, attempt count and timestamp; run-level totals land in the OUTPUT record.
- **Minimal input:**

```json
{ "usernames": ["coolname", "gamer123", "my-brand"] }
```

- **Output field list:** `status`, `requestedUsername`, `username`, `isAvailable`, `errorCode`, `attempts`, `checkedAt`
- **OUTPUT summary keys:** `existingCount`, `availableCount`, `invalidCount`, `otherCount`, `checkedList`

Behaviors an agent should know:

- **500 username hard cap per run** — requests above 500 in `usernames` are rejected; split larger lists across runs.
- `errorCode` is the source of truth for *why*: empty string = checked OK; a non-empty code (e.g. `USERNAME_INVALID_CHARACTERS`, `USERNAME_TOO_SHORT`, `USERNAME_TAKEN`) means unavailable for that specific reason. `isAvailable` reflects the code.
- Repeated/aggressive runs hit `USERNAME_INVALID_RATE_LIMIT` — back off and raise `maxConcurrency` less aggressively; the actor handles retries internally.
- **Apify residential proxy is the default** — Discord rate-limits unproxied requests, so disabling `proxyConfiguration` will cause many checks to fail.
- Spacing is normalized (e.g. `my brand` → `my_brand`); case and most separator chars resolve silently.
- **Billing:** pay-per-result — `result` per checked username (price set by the publisher in monetization settings), + Actor Start ~$0.00005 (Apify default); a 500-handle run is a single cheap call.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Discord Inc. It uses only Discord's **official public signup/username-availability endpoint** — no logins, no user tokens, no self-bot behavior, no private data. Users are responsible for complying with Discord's Terms of Service and applicable law, including rate limits and platform rules; automated monitoring should respect Discord's documented usage policies.

# Actor input Schema

## `usernames` (type: `array`):

List of Discord usernames (handles) to check for availability. Enter one per line — each is reported as available, taken, or invalid. Up to 500 per run.

## `maxConcurrency` (type: `integer`):

How many checks to run in parallel (1–50). Higher is faster but more likely to hit Discord rate limits.

## `proxyConfiguration` (type: `object`):

Proxy used to reach Discord. Leave the default (Apify residential proxy) on — Discord rate-limits unproxied requests, so disabling the proxy will cause many checks to fail.

## Actor input object example

```json
{
  "usernames": [
    "coolname",
    "gamer123"
  ],
  "maxConcurrency": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "usernames": [
        "coolname",
        "gamer123"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/discord-username-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "usernames": [
        "coolname",
        "gamer123",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/discord-username-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "coolname",
    "gamer123"
  ]
}' |
apify call ahmed_jasarevic/discord-username-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/discord-username-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oehphNMh22dizTw8n/builds/MmZubhBKIQwz9lYjn/openapi.json