# Roblox Username Checker - Availability, Bulk & Fast (`neverempty/roblox-username-checker`) Actor

For Roblox players, creators and handle hunters: bulk-check up to 1,000 Roblox usernames per run and get available, taken, not appropriate or invalid with Roblox's own reason. A name Roblox did not answer is never reported as available.

- **URL**: https://apify.com/neverempty/roblox-username-checker.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Games, Developer tools, Automation
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 username checkeds

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

## Roblox Username Checker - Availability, Bulk & Fast

For Roblox players, creators and handle hunters: whether each Roblox username is available, taken, not appropriate or invalid (with Roblox's own answer code, reason and message), plus the time it was checked. Measured on 2026-09-29 with this Actor on Apify: one name in 2.1 s, 815 names in 312 s with no rate limit. Send one name or a list of up to 1,000 in the same run and get one row per name - a name Roblox could not answer is never reported as available.

Export as JSON, CSV or Excel.

Unofficial. Public data only. Not affiliated with, endorsed by or connected to Roblox Corporation.

***

### What it does

You give it usernames. It asks Roblox the same question the sign-up page asks ("can this username be registered?") and returns one row per name.

```json
{
  "usernames": ["builderman", "quietharbor7319", "ab", "a__b"]
}
```

Rows returned for that input (real answers, 2026-09-29):

```json
[
  { "username": "builderman", "taken": true, "available": false, "status": "taken", "reason": null, "robloxCode": 1, "reasonMessage": "Username is already in use", "inputUsername": "builderman", "checkedAt": "2026-09-29T02:38:54.020Z", "source": "roblox" },
  { "username": "quietharbor7319", "taken": false, "available": true, "status": "available", "reason": null, "robloxCode": 0, "reasonMessage": "Username is valid", "inputUsername": "quietharbor7319", "checkedAt": "2026-09-29T02:38:54.310Z", "source": "roblox" },
  { "username": "ab", "taken": null, "available": false, "status": "invalid", "reason": "length", "robloxCode": 3, "reasonMessage": "Usernames can be 3 to 20 characters long", "inputUsername": "ab", "checkedAt": "2026-09-29T02:38:54.546Z", "source": "roblox" },
  { "username": "a__b", "taken": null, "available": false, "status": "invalid", "reason": "more-than-one-underscore", "robloxCode": 5, "reasonMessage": "Usernames can have at most one _", "inputUsername": "a__b", "checkedAt": "2026-09-29T02:38:54.793Z", "source": "roblox" }
]
```

The first three columns - `username`, `taken`, `available` - have the same names and meaning as in other username checkers, so a script that reads those three fields from the dataset does not have to rename them. Results are written to the default dataset only (nothing is written to the key-value store). You can also send a single name in a field called `username` instead of a list.

### Why this one

- **One name or many, same Actor.** Send `{"username": "name"}` for one check, or `usernames` with up to 1,000 names.
- **Four answers, not two.** Roblox's sign-up check separates a name that is free, a name someone already has, a name Roblox's filter rejects, and a name that breaks the format rules. A name that is not in use can still be impossible to register, and this Actor tells you which.
- **Every row says when it was checked** (`checkedAt`, UTC). Availability changes the moment someone registers the name.
- **It does not guess.** If Roblox rate-limits a name after waiting and retrying, blocks the request, or answers with something that is not one of its known answers, that name comes back as a free row with `available: null`, `taken: null` and a note saying why. It is never counted as available.

### What Roblox answers, and what you get

Measured on 2026-09-29. Every answer is HTTP 200 with `{"code": <number>, "message": "<text>"}`:

| Roblox `code` | Roblox's message | `status` | `reason` | Charged |
|---|---|---|---|---|
| 0 | Username is valid | `available` | - | yes |
| 1 | Username is already in use | `taken` | - | yes |
| 2 | Username not appropriate for Roblox | `inappropriate` | `not-appropriate` | yes |
| 3 | Usernames can be 3 to 20 characters long | `invalid` | `length` | yes |
| 4 | Username can't start or end with \_ | `invalid` | `underscore-at-start-or-end` | yes |
| 5 | Usernames can have at most one \_ | `invalid` | `more-than-one-underscore` | yes |
| 6 | Username cannot contain spaces | `invalid` | `contains-spaces` | yes |
| 7 | Only a-z, A-Z, 0-9, and \_ are allowed | `invalid` | `invalid-characters` | yes |
| any other code, HTTP 400, or an unreadable answer | - | `unreadable` (free row, Roblox's message in `note`) | - | no |
| HTTP 429 after waiting and retrying | - | `rate-limited` (free row) | - | no |
| a verification step, a block or an empty answer | - | `blocked` (free row) | - | no |

`inappropriate` covers more than rude words: in the measurements it also came back for names containing other platform names (`facebook`, `instagram_me`, `snapchatme`, `tiktokzq7`) and for `Roblox_Staff`. Roblox does not say which rule matched.

Names are checked as an adult sign-up (birthday 2000-01-01). In six test names the answer was the same with an under-13 birthday; Roblox may filter under-13 sign-ups more strictly for other names.

### Input

| Field | What it does |
|---|---|
| `usernames` | List of usernames, one per line (commas also split). A leading `@` is removed and the letters A-Z are lower-cased - Roblox ignores case too (`BUILDERMAN` and `builderman` got the same answer). A space or symbol inside a name is kept and sent as typed, and Roblox answers `invalid` with its reason. The same name is checked and charged once. Up to 1,000 per run. |
| `username` | One username, for tools that send a single name in a field called `username`. Checked first, together with the list. |

If both are empty, the example names `builderman` and `quietharbor7319` are checked (and charged like any other name), and every row says so in `note`. Input that has only spaces or separators, or names put in a field this Actor does not know, is not replaced by the examples: you get one free row saying so.

### Output columns

| Column | Meaning |
|---|---|
| `username` | The name that was sent to Roblox (leading `@` removed, lower case). |
| `taken` | `true` if Roblox says the name is in use, `false` if it is free, `null` for not-appropriate and invalid names and for free rows. |
| `available` | `true` only when Roblox said the name is valid and free. `false` for taken, not-appropriate and invalid names. `null` on free rows (no answer). |
| `status` | `available`, `taken`, `inappropriate` or `invalid` on charged rows. Free rows: `rate-limited`, `blocked`, `unreadable`, `invalid-input`, `duplicate`, `budget-reached`, `not-checked`. |
| `reason` | Short name of the rule for `inappropriate` and `invalid` names (table above). |
| `robloxCode` | Roblox's answer code (0 - 7). |
| `reasonMessage` | Roblox's own sentence. |
| `inputUsername` | The name exactly as you typed it. |
| `checkedAt` | When the answer came back (ISO 8601, UTC). |
| `note` | Free rows: why there is no answer (free rows are never charged). Charged rows have a `note` only when they answer for the example names. |
| `source` | Always `roblox`. |

### Speed and cost of one check

Measured on Apify on 2026-09-29 with the default 128 MB of memory:

| Run | Time of the run | Time from the API call until the result is ready |
|---|---|---|
| One name | 2.1 s | 4.0 s |
| The example input (2 names) | 3.8 s | 7.1 s |
| 4 names | 2.9 s | 4.0 s |
| 11 inputs (9 names answered, 1 repeated name, 1 empty input) | 4.4 s | 7.2 s |
| 815 names | 312.3 s (about 0.38 s per name, 815 requests, 0 rate limits) | 315.0 s |

A one-name run costs $0.008 - the price of one checked name - and nothing else.

### Pricing

Pay per event: **$8.00 per 1,000 usernames checked** ($0.008 per name), and nothing else - no start fee. You are charged for a name only when Roblox answered for it: `available`, `taken`, `inappropriate` or `invalid`. Rate-limited, blocked and unreadable names, input that is not a name, repeated names and anything the run's maximum total charge did not cover come back as free rows.

If you set a maximum total charge for the run, the Actor checks only as many names as that limit can pay for. The rest are not sent to Roblox, and one free row says how many were left.

### Rate limits and how the requests are made

- The Actor sends one request per name to `https://auth.roblox.com/v1/usernames/validate` - the endpoint Roblox's own sign-up page uses, listed in Roblox's public API documentation as "Checks if a username is valid". No account, login, token or cookie is used.
- **It does not hammer Roblox.** Names are checked one after another with a short pause (0.15 s), never in parallel - about 160 requests a minute in the 815-name run above, while Roblox's own rate-limit header allows 1,000 a minute. When Roblox answers 429, the Actor waits the number of seconds Roblox gives (or 15 seconds if it gives none) and asks again from the same address. If Roblox asks for a wait longer than 60 seconds, the name is not retried. After 3 attempts the name comes back as a free `rate-limited` row.
- **It does not hide who it is.** Requests carry a User-Agent that names this Actor, and it does not rotate proxy addresses to get around a rate limit.
- **It stops instead of spinning.** If 10 names in a row get no answer, or the run is 30 seconds from its timeout, the Actor stops sending and one free `not-checked` row says how many names were left. A name is not retried when the wait and the retry would run past the timeout.
- **Verification steps (CAPTCHA) are never solved or bypassed.** If Roblox answers with one, the name comes back as a free `blocked` row.
- `auth.roblox.com` has no `robots.txt` (it answers 404, checked 2026-09-29), and the `robots.txt` of `www.roblox.com` does not cover this path. Roblox's Terms of Use (version of 2026-09-22) ask API users to use an API only as documented and not to misrepresent or mask their identity; the two points above are how this Actor follows that.

### Limits

- Up to 1,000 names per run. Split longer lists across runs.
- An `available` answer means "free at `checkedAt`". Anyone can register it a second later.
- Roblox usernames are 3 - 20 characters of letters, digits and at most one underscore. Anything else comes back `invalid` with Roblox's reason (and is charged, because Roblox answered).
- Display names are not checked: Roblox display names do not have to be unique.
- Roblox's documentation marks this v1 endpoint as not recommended and points to a newer version, so Roblox may change or close it.
- If Roblox changes or closes this endpoint, or starts requiring a verification step for it, the Actor stops returning answers (you get free rows saying so) rather than guessing.

### FAQ

**Is a rate-limited name charged?** No. Only names Roblox answered for are charged.

**Why is `taken` null for a not-appropriate or invalid name?** Roblox did not say whether it is in use - it said the name cannot be registered at all. `available` is `false` because you cannot claim it.

**Can a name be free and still not available?** Yes. `inappropriate` names and names that break the format rules cannot be registered even if nobody has them.

# Actor input Schema

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

One Roblox username per line (or several separated by commas). A leading @ is removed and the letters A-Z are lower-cased, as Roblox ignores case. A space or symbol inside a name is kept and sent as typed, and Roblox answers invalid with its reason. Each name gets one row: available, taken, not appropriate, or invalid with Roblox's reason (for example 3 to 20 characters, or at most one underscore). The same name is checked and charged once. Up to 1,000 names per run, checked one after another with a short pause, never in parallel. If this and the single username field are both empty, the example names builderman and quietharbor7319 are checked (and charged like any other name), and every row says so in note.

## `username` (type: `string`):

One username, for tools that send a single name in a field called username (the same field name other username checkers use). It is checked first, together with anything in the list above.

## Actor input object example

```json
{
  "usernames": [
    "builderman",
    "quietharbor7319"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

One row per username: the name as checked, taken (true/false), available (true/false), status (available, taken, inappropriate or invalid), Roblox's answer code, reason and message, the name exactly as you typed it, and the time it was checked. Names Roblox did not answer for (rate limits, blocks, unreadable answers), input that is not a name, repeated names and anything cut short by the run's charge limit come back as free rows with a note, and available and taken set to null.

# 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": [
        "builderman",
        "quietharbor7319"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/roblox-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": [
        "builderman",
        "quietharbor7319",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/roblox-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": [
    "builderman",
    "quietharbor7319"
  ]
}' |
apify call neverempty/roblox-username-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/roblox-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/IzLv3E5OmkNhz44tU/builds/lkyQSs7fQ8y2f3EiN/openapi.json