# Username Availability Checker Across Sites | $1/1K (`one_dollar_store/username-availability-checker`) Actor

$1 per 1,000 results, platform usage included. Check usernames across developer, creator, gaming and social sites: one row per username and site with status found, available or unknown. Public profile pages and APIs only, every site rule tested on each run.

- **URL**: https://apify.com/one_dollar_store/username-availability-checker.md
- **Developed by:** [One Dollar Store](https://apify.com/one_dollar_store) (community)
- **Categories:** Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## Username Availability Checker: one row per username and site

**$1 per 1,000 checks. Platform usage included. No rental, no minimum.**

[Open it in Apify Console](https://console.apify.com/actors/0nCg1sTByrJsAttAI/input)

### What it costs

| Checks | Cost |
|---|---|
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

A check is one username on one site. Plus $0.001 per run. One flat price, platform usage included, so there is no separate compute or proxy bill. Checking 5 usernames on all sites in the list costs about $0.18 (175 checks plus the run).

### Why use it

- **A false "available" is treated as the worst answer.** A site only counts when the answer matches an exact rule (listed in the table below), and every run tests each rule first with a known account and an unused name. If a site fails its own test that day, you get `unknown` with the reason, not a guess.
- **Three clear statuses.** `found`, `available` or `unknown`. Unknown always carries a reason: blocked, rate limited, not a valid name there, or the site failed its test.
- **Public pages and public APIs only.** No login, no CAPTCHA solving, no proxy. A site that blocks the check or gives an unclear answer is reported as `unknown` instead of being worked around.
- **robots.txt respected.** Each site's robots.txt is read, and an address it does not allow is not requested.

### Quick start

1. Open the actor, list your usernames, press **Start**.
2. Or paste this input:

```json
{ "usernames": ["octocat", "my-new-brand"], "maxItems": 100 }
```

3. Download the results as JSON, CSV or Excel, or read them through the API.

To check only some sites: `{ "usernames": ["my-new-brand"], "platforms": ["github", "gitlab", "devto"] }`.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/one_dollar_store~username-availability-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames": ["my-new-brand"], "platforms": ["github", "gitlab", "devto"]}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("one_dollar_store/username-availability-checker").call(
    run_input={"usernames": ["my-new-brand"], "maxItems": 100}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["username"], row["platformName"], row["status"])
```

### Use it from an AI assistant

Claude, ChatGPT, Cursor and other assistants can call this actor through Apify's MCP server. Add it with this server address:

```
https://mcp.apify.com?tools=one_dollar_store/username-availability-checker
```

Then ask, for example: "Is the username my-new-brand free on GitHub, GitLab and Dev.to?"

### Switching from another username checker

Most username checkers take a list of usernames and a list of sites. Here they are `usernames` and `platforms` (site ids from the table below). The core fields are `username`, `platform`, `status` and `profileUrl`.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `usernames` | list of text | none | Usernames to check, one per line. A leading `@` or a profile link is cut down to the username. Up to 500 usernames. Letters, digits, dot, dash and underscore only. |
| `platforms` | list of text | all sites | Site ids from the table below. Leave empty to check every site. |
| `maxItems` | number | 200 | Total checks (rows) for the run. Minimum 10. |

### Output fields

One row is one username on one site.

| Field | Meaning |
|---|---|
| `username` | The username as you gave it. |
| `platform`, `platformName`, `group` | Site id, display name and group (developer, packages, gaming, social, creator). |
| `status` | `found` (the site shows an account), `available` (the site gave its clear not-found answer) or `unknown`. |
| `profileUrl` | Where the profile is, or would be. |
| `httpStatus` | The site's HTTP answer, when there was one. |
| `reason` | Only for `unknown`: why the answer is not certain. |
| `checkedAt` | Time of the check, UTC. |

### How each answer is decided

A row is `found` only when the site's answer matches its found rule, and `available` only when it matches its available rule. Anything else, including blocks, rate limits, timeouts, redirects to a login page and odd replies, is `unknown`. Before any username is checked on a site, the actor checks that site's rules with a known account (it must read as found) and an unused random name (it must read as available). If either fails, every row for that site in the run is `unknown` with the reason. The run summary lists the result of this self test for each site.

### Sites and their rules

35 sites were on the list on 9 October 2026. Each one is requested at the address shown by its profile link, with a plain GET (one POST for Roblox). `found` and `available` are decided only by the rules below. Anything else is `unknown`.

| Id | Site | Group | Found when | Available when |
|---|---|---|---|---|
| `github` | GitHub | developer | HTTP 200 | HTTP 404 |
| `bitbucket` | Bitbucket | developer | HTTP 200 | HTTP 404 |
| `sourcehut` | SourceHut | developer | HTTP 200 | HTTP 404 |
| `devto` | DEV Community | developer | HTTP 200 | HTTP 404 |
| `hackernews` | Hacker News | developer | HTTP 200 and JSON `id` is present | HTTP 200 and JSON `the reply` is empty (null) |
| `keybase` | Keybase | developer | HTTP 200 and JSON `them.0.basics.username` is present | HTTP 200 and JSON `them.0` is empty (null) |
| `dockerhub` | Docker Hub | packages | HTTP 200 | HTTP 404 |
| `cratesio` | crates.io | packages | HTTP 200 | HTTP 404 |
| `rubygems` | RubyGems | packages | HTTP 200 | HTTP 404 |
| `nuget` | NuGet | packages | HTTP 200 | HTTP 404 |
| `packagist` | Packagist | packages | HTTP 200 | HTTP 404 |
| `hexpm` | Hex | packages | HTTP 200 | HTTP 404 |
| `huggingface` | Hugging Face | developer | HTTP 200 | HTTP 404 |
| `codewars` | Codewars | developer | HTTP 200 | HTTP 404 |
| `codeforces` | Codeforces | developer | HTTP 200 and JSON `status` equals OK | HTTP 400 and page says "not found" and JSON `status` equals FAILED |
| `exercism` | Exercism | developer | HTTP 200 | HTTP 404 |
| `wordpressorg` | WordPress.org | developer | HTTP 200 | HTTP 404 |
| `minecraft` | Minecraft (Mojang) | gaming | HTTP 200 and JSON `id` is present | HTTP 404 |
| `roblox` | Roblox | gaming | HTTP 200 and JSON `data` is not empty | HTTP 200 and JSON `data` is an empty list |
| `scratch` | Scratch | gaming | HTTP 200 | HTTP 404 |
| `steam` | Steam (custom URL) | gaming | HTTP 200 and page does not say "The specified profile could not be found" | HTTP 200 and page says "The specified profile could not be found" |
| `itchio` | itch.io | gaming | HTTP 200 | HTTP 404 |
| `mastodonsocial` | Mastodon (mastodon.social) | social | HTTP 200 | HTTP 404 |
| `bluesky` | Bluesky (bsky.social) | social | HTTP 200 | HTTP 400 and page says "Profile not found" |
| `tumblr` | Tumblr | social | HTTP 200 | HTTP 404 |
| `openstreetmap` | OpenStreetMap | social | HTTP 200 | HTTP 404 |
| `duolingo` | Duolingo | social | HTTP 200 and JSON `users` is not empty | HTTP 200 and JSON `users` is an empty list |
| `soundcloud` | SoundCloud | creator | HTTP 200 | HTTP 404 |
| `youtube` | YouTube (@handle) | creator | HTTP 200 | HTTP 404 |
| `substack` | Substack | creator | HTTP 200 | HTTP 404 |
| `gumroad` | Gumroad | creator | HTTP 200 | HTTP 404 |
| `aboutme` | About.me | creator | HTTP 200 | HTTP 404 |
| `goodreads` | Goodreads | creator | HTTP 200 | HTTP 404 |
| `wattpad` | Wattpad | creator | HTTP 200 | HTTP 404 |
| `myanimelist` | MyAnimeList | creator | HTTP 200 | HTTP 404 |

We tried 53 sites before settling on this list. Left out on 9 October 2026: GitLab, Lichess, Chess.com, Speedrun.com, Gravatar, Wikipedia, Mixcloud, Linktree and Flickr (their robots.txt asks automated clients not to request the address), Newgrounds and Codeberg (robots.txt could not be read), PyPI, Last.fm and Bandcamp (an unused name also answers as found), Buy Me a Coffee (a known account reads as not found), Vimeo (no clear answer), Blogger (rate limiting) and Launchpad (requests time out). Big social networks such as Instagram, X, TikTok, Reddit and Facebook are not here: they need a login or block plain requests, so they cannot give a trustworthy answer.

### Limits

- `available` means the site's own address for that username gave its clear not-found answer. It does not promise that you can register the name. Sites keep reserved words, banned names and minimum lengths that are not visible from outside. Always confirm at sign up.
- `found` can also be a page that exists but is not a personal profile, such as an organisation or a reserved route. The `profileUrl` lets you check.
- Usernames are checked as typed. A name that cannot exist on a site (too short, too long, wrong characters) is `unknown` with the reason `not a valid username on <site>`, not `available`.
- A site that fails its self test on the day is left out of the results and listed in the run summary under `sitesLeftOut`. If you name a site in `platforms` and it fails, you get `unknown` rows that say why.
- Sites rate limit. The actor spaces its requests per site, retries once, and reports `unknown` (`rate limited`, `no answer`) rather than guessing.
- Only public pages and public APIs, no login, no proxy, no CAPTCHA solving. Each site's robots.txt is read and followed. If a site changes its pages, its self test fails and the site drops out until its rule is updated.
- Each run first sends two test requests per site (a known account and an unused name) and reads each site's robots.txt, about 110 requests across 35 sites, before your usernames are checked. Two usernames on every site took about 40 seconds in our test.
- Up to 500 usernames per run. Every row is a charged result, so the run stops at `maxItems`.

### FAQ

**How much does it cost to check 1,000 usernames on 10 sites?**
10,000 checks, so $10, plus $0.001 for each run.

**Do I pay for compute or proxy on top?**
No. Platform usage is included in the $1 per 1,000 price. The actor needs no proxy.

**Why is a site missing from my results?**
It failed its self test on that run (the site changed, blocked the request or was slow). The run summary lists it under `sitesLeftOut` with the reason.

**Why not check Instagram, X or TikTok?**
Their pages answer the same way for real and made up names, or need a login, or block plain requests. A checker that guessed there would report false `available` results, which is the worst kind of mistake.

**Can I check a name before I register a brand?**
It is a good first screen: run it across the sites and look at `found` and `unknown`. Then check the trademark register and the sign up pages of the sites you care about.

**Is it legal?**
The actor requests public profile addresses and public APIs, as a visitor or a script would, follows each site's robots.txt and does not log in. Follow each site's terms and the law where you live, and do not use results to harass people or impersonate accounts.

**Is this an official product of any of these sites?**
No. It is an independent tool and is not affiliated with or endorsed by any site on the list.

**Do I need an Apify account?**
Yes. Actors run from an Apify account, and a free account is enough to start: it includes $5 of platform usage every month. You can [sign up here](https://www.apify.com?fpr=ymnoit). This is a referral link and it costs you nothing.

**Is there a limit on the free plan?**
Yes. A run started from a free plan account delivers the first 10 results, then ends with a message and a link to the plans. Any paid plan returns everything you ask for, up to your own limit. The price per result is the same on every plan.

### More from The One Dollar Store

Every actor here costs $1 per 1,000 results, platform usage included. See the whole store: https://apify.com/one_dollar_store

**Social media**

- [Threads Scraper](https://apify.com/one_dollar_store/threads-post-scraper): Public Threads posts by keyword or profile.
- [Instagram Profile Scraper](https://apify.com/one_dollar_store/instagram-profile-data-scraper): Followers, posts and engagement for public profiles.
- [TikTok Hashtag Scraper](https://apify.com/one_dollar_store/tiktok-hashtag-videos-scraper): Videos, views and creators for any hashtag.
- [Pinterest Pin Search Scraper](https://apify.com/one_dollar_store/pinterest-pin-search-scraper): Public pins with images and outbound links.
- [Telegram Channel Scraper](https://apify.com/one_dollar_store/telegram-channel-posts-scraper): Posts, views and media from public channels.
- [Xiaohongshu Scraper](https://apify.com/one_dollar_store/xiaohongshu-explore-feed-scraper): RedNote notes from the public explore feeds.
- [Facebook Ad Library Scraper](https://apify.com/one_dollar_store/facebook-ad-library-scraper): Meta ads by keyword or advertiser page.
- [Podcast Episodes Scraper](https://apify.com/one_dollar_store/podcast-episodes-scraper): Episodes from Apple Podcasts and RSS feeds.

### Changelog

- October 2026: first release.

# Actor input Schema

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

The usernames to check, one per line. A leading @ or a profile link is cut down to the username. Up to 500 usernames.

## `platforms` (type: `array`):

Optional. Site ids to check, for example github, gitlab, devto. Leave empty to check every site on the list. The README lists all ids.

## `maxItems` (type: `integer`):

One result is one username on one site. The run stops after this many. Minimum 10.

## Actor input object example

```json
{
  "usernames": [
    "octocat",
    "zq81mxkw3d"
  ],
  "maxItems": 100
}
```

# Actor output Schema

## `results` (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": [
        "octocat",
        "zq81mxkw3d"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("one_dollar_store/username-availability-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": [
        "octocat",
        "zq81mxkw3d",
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("one_dollar_store/username-availability-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": [
    "octocat",
    "zq81mxkw3d"
  ],
  "maxItems": 100
}' |
apify call one_dollar_store/username-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,one_dollar_store/username-availability-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/0nCg1sTByrJsAttAI/builds/yRlcts3VwJXhtLMvS/openapi.json