# All In One Username Availability Checker (`scrapers-hub/all-in-one-username-availability-checker`) Actor

All-In-One Username Availability Checker tests a handle across dozens of social platforms and returns platform, profile URL and availability status. 🔍 Perfect for brand protection, naming research, OSINT and claiming a consistent username everywhere.

- **URL**: https://apify.com/scrapers-hub/all-in-one-username-availability-checker.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 🔎 All In One Username Availability Checker – Check Handle Availability Across 85+ Platforms

The All In One Username Availability Checker tells you, in a single run, whether a username is free or already taken across more than eighty-five social, creative, developer, commerce and messaging platforms. Type one handle, choose "All", and get back a clean row for every platform showing its availability status and — where the handle is already claimed — a direct link to the existing profile.

Picking a handle is a one-time decision with a long tail of consequences. A name that is free on X but taken on Instagram, GitHub and Substack forces years of inconsistent branding, mismatched links and confused audiences. This username availability checker collapses what would otherwise be eighty-five manual signup attempts into one query, so you can shortlist names that are actually available everywhere before you commit to one.

***

### 📊 What Data Can You Extract with This Username Availability Checker?

Every dataset item represents one platform's verdict on the handle you searched. Four fields, no nesting.

| Category | Fields | What it gives you |
| --- | --- | --- |
| 🆔 Record identity | `id` | A unique identifier for the individual check, useful as a primary key when loading results into a database |
| 🌐 Platform | `platform` | The name of the platform this row reports on, for example `github`, `reddit` or `medium` |
| ✅ Availability verdict | `status` | `Available`, `Not Available`, or `Unknown` where a platform cannot be checked reliably |
| 🔗 Existing profile | `profile_url` | The URL of the profile that already holds the handle, populated when the status is `Not Available` |
| 📥 Query context | driven by `keyword` and `platform` inputs | Whether the run covered every supported platform or was narrowed to a single one |

The field that changes how you work is `profile_url`. A plain "taken" answer leaves you guessing whether the handle belongs to an active account, a dormant one, or a squatter. Because the checker returns the actual profile address whenever a handle is claimed, you can open the link and judge immediately whether the name is genuinely lost or worth pursuing.

***

### 🌟 Key Features of the Username Availability Checker

| Feature | Description |
| --- | --- |
| 🌍 85+ platform coverage | One run checks a handle across social networks, developer platforms, creative portfolios, marketplaces, streaming services and messaging apps |
| 🎯 Single-platform mode | The `platform` input accepts any one supported platform name, so you can check just GitHub, just Reddit or just Instagram when that is all you need |
| 🔗 Profile URL on collisions | When a handle is taken, the checker returns the URL of the profile holding it rather than a bare boolean |
| 🚦 Three-state status | `Available`, `Not Available` and `Unknown` — the third state is reported honestly rather than being guessed at |
| 🔀 Automatic proxy rotation | Requests are routed through rotating proxies automatically, with retries, so transient blocks do not silently corrupt results |
| 📐 Flat four-field schema | Every row has the same four scalar keys, which means CSV exports and database loads need no flattening |
| 🔢 Stable record IDs | Each check carries a unique `id`, making it straightforward to deduplicate or upsert results across repeated runs |
| ⚡ No headless browser | The checker uses HTTP requests and lightweight HTML parsing rather than rendering pages, keeping runs fast |
| 📤 Full Apify export options | Results are written to an Apify dataset and can be downloaded as JSON, CSV, XLSX, XML or HTML, or fetched via API |

***

### 🚀 Why Choose This Username Availability Checker?

**Breadth in a single query.** Checking a handle by hand means opening a signup form on every platform you care about and reading the error messages. Covering eighty-five platforms that way is a morning's work per candidate name. Here it is one run, and comparing five candidate names is five runs.

**Honest `Unknown` results.** Some platforms cannot be probed reliably without an account, and a checker that guesses in those cases is worse than useless — it produces confident answers that are sometimes wrong. This one reports `Unknown` for platforms such as Instagram and Twitch instead of inventing a verdict, so you know exactly which handles still need a manual look.

**Actionable collision data.** The `profile_url` field turns "taken" into something you can act on. An abandoned account with no posts is a very different obstacle from an active profile with a large following, and you can only tell the difference by looking at the profile the checker hands you.

**Results shaped for tooling, not for reading.** The output is a flat dataset with stable identifiers, so it slots into spreadsheets, brand-monitoring dashboards and internal naming tools without transformation. Run it on a schedule and you have a change log of when handles free up.

***

### 📥 Input

The username availability checker takes the handle to check and, optionally, a single platform to narrow the search to.

```json
{
  "keyword": "emilywritespoem",
  "platform": "All"
}
```

#### 🔧 Username Availability Checker Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `keyword` | string | ✅ Yes | `emilywritespoem` | The username to search for across platforms. |
| `platform` | string (enum) | ❌ No | `All` | Which platform to check. Choose `All` to check every supported platform, or pick a single one from the list — options include `X`, `Reddit`, `Github`, `Medium`, `Twitch`, `Instagram`, `Myanimelist`, `Anilist`, `Gumroad`, `Youtube`, `Bluesky`, `Linktree`, `TikTok`, `Pinterest`, `LinkedIn`, `Tumblr`, `Vimeo`, `SoundCloud`, `Spotify`, `StackOverflow`, `Quora`, `Telegram`, `Discord`, `Substack`, `Patreon`, `Etsy`, `Ebay`, `Behance`, `Dribbble`, `Deviantart`, `Goodreads` and many more. |
| `proxyConfiguration` | object | ❌ No | — | Optional proxy configuration object. Proxy rotation is handled automatically by the Actor, so this can normally be left untouched. |

#### 💡 Input Examples

**Full sweep across every supported platform**

```json
{
  "keyword": "acmestudio",
  "platform": "All"
}
```

**Check a single platform only**

```json
{
  "keyword": "acmestudio",
  "platform": "Github"
}
```

**Checking a personal brand handle**

```json
{
  "keyword": "emilywritespoem",
  "platform": "All"
}
```

***

### 📤 Output

Each item is one platform's verdict on the handle. A run with `platform` set to `All` produces one item per supported platform.

```json
{
  "id": "a7f3c1d9e2",
  "platform": "github",
  "profile_url": "https://github.com/emilywritespoem",
  "status": "Not Available"
}
```

An available handle returns an empty `profile_url`, because there is no profile to link to:

```json
{
  "id": "b2e8a04c7f",
  "platform": "medium",
  "profile_url": "",
  "status": "Available"
}
```

#### 🧾 Username Availability Checker Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | integer | Unique identifier of the check record |
| `platform` | string | null | The platform this row reports on |
| `profile_url` | string | null | URL of the existing profile page, populated when the handle is already taken |
| `status` | string | null | `Available`, `Not Available`, or `Unknown` where the platform cannot be checked reliably |

Note the relationship between the last two fields: `profile_url` is only meaningful when `status` is `Not Available`. Treat an empty `profile_url` alongside an `Available` status as the normal, expected combination.

***

### 💻 How to Use the Username Availability Checker (Step by Step)

#### Step 1: Open the Username Checker on Apify

Sign in to your Apify account and open the All In One Username Availability Checker Actor. The Actor runs entirely on Apify's infrastructure — there is nothing to install, no proxy credentials to source and no platform accounts to create. The page gives you an input form, a live log and a dataset tab where results appear as each platform is checked.

#### Step 2: Enter the Username You Want to Check

Type your candidate handle into the **Username** field. Enter it exactly as you intend to register it, without a leading `@`. Case generally does not matter for availability, but the exact character sequence does: `acme_studio` and `acmestudio` are entirely different handles and will return entirely different results.

#### Step 3: Decide Between All Platforms and One

Leave **Platform** on `All` for a full sweep — this is the right choice when you are evaluating a name for a new brand or persona and need to know where it survives. Select a single platform instead when you already know which network matters and want a fast, focused answer, for example checking only GitHub before naming an open-source project.

#### Step 4: Run the Checker and Follow the Log

Press **Start**. The log reports each platform as it is checked, along with the verdict. Because requests go out through rotating proxies with retries, an individual platform that responds slowly or rejects the first attempt is retried rather than being dropped. Platforms that ultimately cannot be reached are logged and skipped.

#### Step 5: Read the Status Column

Open the **Dataset** tab and sort by `status`. The `Available` rows are your opportunity list. The `Not Available` rows come with a `profile_url` you can click to inspect the incumbent account. The `Unknown` rows — typically Instagram and Twitch — are the handful you should verify manually on the platform's own signup form.

#### Step 6: Compare Candidate Names Side by Side

Naming decisions are comparative. Run the checker once per candidate handle, export each dataset, and stack them in a spreadsheet with `platform` as the row key and each candidate as a column. The name with the most `Available` verdicts across the platforms you actually care about is usually the right answer, and the comparison takes minutes.

#### Step 7: Export, Automate or Monitor

Download results as CSV or JSON, or connect the Actor to a scheduler. Handles do get released when accounts are deleted, so scheduling a weekly run against a handle you want and alerting on any `status` flipping to `Available` is a practical way to catch a name the moment it frees up.

***

### 🔌 API Access & Integrations

Run the username availability checker and get the results in the same request:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~all-in-one-username-availability-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "emilywritespoem",
    "platform": "All"
  }'
```

The same call with the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/all-in-one-username-availability-checker").call(
    run_input={
        "keyword": "emilywritespoem",
        "platform": "All",
    }
)

available = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("status") == "Available":
        available.append(item["platform"])

print("Free on:", ", ".join(available))
```

Results can also be pushed automatically to Zapier, Make, Google Sheets and Slack, or to any endpoint you control using Apify webhooks that fire when a run completes.

***

### 💡 Best Use Cases for Username Availability Data

#### 🏷️ Brand Naming and Launch Preparation

Before a company, product or podcast name is locked in, run every shortlisted handle through the availability checker. A name where `status` is `Available` across all the platforms in your channel plan is worth far more than one that is only free on your primary network, because consistent handles are what make a brand searchable.

#### 🎨 Creator and Personal Brand Setup

Creators building an audience across several networks need one recognisable handle. Sweeping all platforms in one run shows exactly which candidate survives everywhere, and the `profile_url` values reveal whether the collisions are dormant accounts or active competitors for the name.

#### 🛡️ Brand Protection and Squatter Detection

Run your own official handle and its near-miss variants. Any variant returning `Not Available` with a `profile_url` you do not recognise is a candidate impersonation or squatting account, and the link goes straight to your trust-and-safety team for review.

#### 📡 Handle Monitoring and Release Watching

Desirable handles occasionally free up when accounts are deleted or purged. Scheduling a recurring run against a specific `keyword` and watching for `status` to change from `Not Available` to `Available` gives you an early alert rather than a lucky discovery.

#### 🧑‍💻 Open-Source Project and Package Naming

Before naming a library, check the handle on developer-facing platforms. A `Github` result of `Not Available` for your intended organisation name is a blocking problem worth discovering before the README is written, not after.

#### 🔍 OSINT Footprint Indication

Because `Not Available` rows include a `profile_url`, a full sweep of a known handle doubles as a footprint indication: it shows which platforms already host an account under that name and gives you the addresses to review. Treat matches as leads requiring corroboration, not as proof of identity.

#### 📋 Agency Client Onboarding

Agencies setting up social presence for a new client can run the client's preferred handle once and deliver a complete availability report as a spreadsheet. It turns a tedious manual audit into a two-minute deliverable and starts the naming conversation from evidence.

***

### ⚙️ Tips for Better Username Availability Checking

- **Check variants alongside your first choice.** Underscore, dot and short-suffix versions of a handle often survive where the plain form does not. Running three or four variants gives you a realistic set of options rather than a single disappointment.
- **Treat `Unknown` as a to-do, not a result.** Platforms reported as `Unknown` — Instagram and Twitch among them — need a manual check on their own signup page. Do not assume availability from the absence of a definitive answer.
- **Open the `profile_url` before writing a name off.** An account with no avatar, no posts and no followers is a very different obstacle from an active one, and some platforms release inactive handles on request.
- **Use single-platform mode for speed.** If only one network matters for the decision at hand, set `platform` to that network. A single-platform run finishes far quicker than a full eighty-five-platform sweep.
- **Re-check before you commit.** Availability changes constantly. Run the checker again immediately before registering, because a handle that was free last week may have been claimed since.
- **Keep every run's dataset.** Storing results over time gives you a history of when specific handles were taken or released, which is genuinely useful for both monitoring and disputes.

***

### 🛠️ Troubleshooting

**Why do Instagram and Twitch always show `Unknown`?**
Those platforms cannot be probed reliably without an authenticated session, so the checker reports `Unknown` rather than guessing. This is deliberate — a wrong confident answer would be worse than an honest absence of one. Verify those two manually.

**A handle shows `Available` but the platform refuses my registration.**
Platforms apply their own additional rules: reserved words, trademark holds, minimum lengths, character restrictions and previously-deleted-account cooldowns. The checker reports whether a public profile exists, which is not identical to whether registration will be permitted.

**Some platforms are missing from my results.**
The run emits a row per platform that was successfully checked. If a platform is absent, its request did not complete on that run — usually a transient block or timeout. Re-running normally fills the gap.

**`profile_url` is empty on a row marked `Not Available`.**
The URL is only populated for platforms with a known public profile-URL pattern. A taken handle on a platform without such a pattern still reports `Not Available` correctly, but has no link to offer.

**The run is taking a long time.**
A full sweep contacts a large number of platforms, each with retries on failure. If you only need one platform, use the `platform` input to narrow the run — it is dramatically faster than checking everything.

***

### ❓ Frequently Asked Questions About Username Availability Checking

**What does the All In One Username Availability Checker do?**
It is a username availability checker that takes a single handle and reports whether it is free or taken on more than eighty-five platforms, returning a status per platform plus the profile URL of any existing account holding the name.

**How many platforms does it check?**
Over eighty-five, spanning social networks, developer platforms, creative portfolios, marketplaces, streaming, blogging and messaging services. You can also target any single one of them using the `platform` input.

**Can I check more than one username at a time?**
The `keyword` input takes one handle per run. To compare candidates, run the checker once per name and combine the exported datasets — the flat schema makes stacking them in a spreadsheet trivial.

**What do the three status values mean?**
`Available` means no public profile was found at that handle. `Not Available` means an existing profile was detected. `Unknown` means the platform could not be checked reliably and needs a manual verification.

**Does the checker give me the URL of the account that took my handle?**
Yes, whenever the platform has a known public profile-URL pattern. The `profile_url` field is populated on `Not Available` rows so you can inspect the incumbent account directly.

**Is `Available` a guarantee that I can register the name?**
No. It means no public profile was detected. Platforms also enforce reserved-word lists, trademark protections, length and character rules, and cooldowns on recently deleted accounts.

**Do I need accounts or API keys on the platforms being checked?**
No. The checker requires no platform credentials, no cookies and no logins. You only need an Apify account to run the Actor.

**Does it need proxies configured?**
No. Proxy rotation and retries are handled automatically, which is what keeps results consistent across a large number of platforms in one run.

**How current are the results?**
They reflect the moment the run executed. Handle availability changes continuously, so re-run immediately before registering anything important.

**Can I run the availability checker on a schedule?**
Yes. Apify's scheduler supports any cron expression, which makes recurring monitoring of a specific handle straightforward. Pair it with a webhook to be alerted when a status changes.

**What export formats are supported?**
JSON, CSV, XLSX, XML, RSS and HTML from the Apify dataset UI, plus programmatic access through the dataset API endpoint.

**Why does the same handle show as taken on one platform and free on another?**
Handles are allocated independently by each platform and are not globally unique. This is precisely why a cross-platform username availability checker is useful — consistency across networks cannot be assumed.

**Can I use this for brand protection monitoring?**
Yes. Check your official handle and its plausible misspellings on a schedule; any variant returning `Not Available` with an unfamiliar `profile_url` is a candidate impersonation account worth reviewing.

**Does the checker use a headless browser?**
No. It works through HTTP requests and lightweight HTML parsing, which is why a broad multi-platform sweep completes without the overhead of page rendering.

**What is the `id` field for?**
It is a unique identifier for each check record. It is most useful as a primary key when loading results into a database or when deduplicating across repeated runs.

***

### 🆘 Support & Feedback

If a platform is returning inconsistent verdicts or you have hit a bug, please open a ticket on the **Issues** tab of this Actor and include the run ID plus the handle you searched. Reports filed there are tracked and resolved fastest.

Need additional platforms added, bulk handle checking, or a custom availability-monitoring pipeline built around your own naming process? Email **scraperhubapi@gmail.com** with the details.

If this username availability checker saves you time, please leave a review on the Actor page. Ratings and written feedback shape which platforms and features are added next.

***

### ⚖️ Disclaimer

This username availability checker works only with publicly accessible information. It checks whether a public profile page exists for a handle and, where one does, returns its public address. It does not log in to any platform, bypass authentication, access private profiles or retrieve content behind a login wall.

You are responsible for how you use the results. Availability data can point to accounts belonging to identifiable individuals, so if you process it in a jurisdiction covered by the GDPR, the UK GDPR, the CCPA or similar privacy law, you must establish a lawful basis, respect data-subject rights and apply appropriate retention and security controls. Using the checker to support harassment, impersonation, stalking or targeted intimidation is prohibited.

Respect the terms of service of every platform involved and comply with all applicable laws in your jurisdiction. An `Available` status is an observation, not legal or trademark clearance — check trademark registers separately before adopting a name commercially.

If you believe data about you has been collected through this Actor and you would like it removed, contact **scraperhubapi@gmail.com** and we will action the request.

# Actor input Schema

## `keyword` (type: `string`):

A username to search for

## `platform` (type: `string`):

Select a platform to check. Choose "All" to check every platform.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keyword": "emilywritespoem",
  "platform": "All"
}
```

# Actor output Schema

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

Records scraped by All In One Username Availability Checker, stored in the run's default dataset.

# 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 = {
    "keyword": "emilywritespoem"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/all-in-one-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 = { "keyword": "emilywritespoem" }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/all-in-one-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 '{
  "keyword": "emilywritespoem"
}' |
apify call scrapers-hub/all-in-one-username-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/all-in-one-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/eZuJPUsMoF06hW5qO/builds/h4EbatPbsSL710AfG/openapi.json