# Brand & Username Availability Checker (`maged120/brand-username-checker`) Actor

Checks a brand name or handle across 9 social platforms and any domain extension in a single run, and tells you exactly where it is still free.

- **URL**: https://apify.com/maged120/brand-username-checker.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Categories:** Lead generation, SEO tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Brand & Username Availability Checker

**Check a brand name across 9 social platforms and every domain extension you care about — in one run.** Paste a shortlist of candidate names and get back a clean table showing exactly where each one is still free, and who owns it where it isn't.

### What does Brand & Username Availability Checker do?

Naming a company, a product, or a creator account means checking the same name over and over on a dozen different sites. This Actor does the whole sweep at once: it checks **Instagram, X (Twitter), TikTok, YouTube, Snapchat, Pinterest, Twitch, Discord and GitHub**, plus domain registration for any extensions you pick (`.com`, `.io`, `.ai`, `.app` and more).

For handles that are already taken it also returns **who has them** — display name, follower count where available, and a direct link to the profile — so you can tell an abandoned account apart from an active brand.

Every check runs over a fast, purpose-built path. No browser, no login, no API keys, no manual captchas. A name is checked across all platforms in roughly a second.

Running on Apify means you also get a REST API, scheduling, webhooks, and integrations with Google Sheets, Slack, Zapier and Make — so you can wire name checks straight into your naming workflow.

### Why use Brand & Username Availability Checker?

- **Naming a startup or product** — screen a shortlist of 50 candidate names in a single run instead of 500 manual lookups.
- **Launching a brand** — confirm you can hold the same handle everywhere before you print anything.
- **Naming agencies and brand consultants** — deliver a client-ready availability matrix as a spreadsheet.
- **Domain investors** — pair domain availability with social handle availability to spot genuinely clean names.
- **Creators and influencers** — find one handle that is free across every platform you plan to grow on.
- **Brand protection** — monitor whether someone has registered your brand name on a platform you don't use yet.
- **Bulk research** — feed in a generated name list and rank the results by how many platforms are still open.

### How to use Brand & Username Availability Checker

1. Open the Actor in Apify Console and click **Try for free**.
2. Paste your candidate names into **Names to Check** — bare names, `@handles`, or profile URLs all work.
3. Pick the **Platforms** you care about, and the **Domain Extensions** to check.
4. Click **Start**.
5. Read the results in the **Output** tab — use the **Name Summary** view to rank candidates fast.
6. Export to JSON, CSV, Excel, or pull the results from the API.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `names` | array | — | Names or handles to check. `@handle` and profile URLs are normalized automatically. |
| `platforms` | array | all 9 | Which platforms to check each name against. |
| `checkDomains` | boolean | `true` | Also check domain registration. |
| `domainTlds` | array | com, net, org, io, co | Which domain extensions to check per name. |
| `includeSummary` | boolean | `true` | Add one summary result per name. |
| `proxyConfiguration` | object | disabled | Optional. Only needed for very large name lists. |

```json
{
    "names": ["mybrandidea", "another-name", "@thirdoption"],
    "platforms": ["instagram", "x", "tiktok", "youtube", "github"],
    "checkDomains": true,
    "domainTlds": ["com", "io", "ai"],
    "includeSummary": true
}
```

### Output

Every check is its own row, ready for a spreadsheet. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

A `platform_check` row per name per platform:

```json
{
    "entityType": "platform_check",
    "name": "nike",
    "platform": "tiktok",
    "platformTitle": "TikTok",
    "isAvailable": false,
    "profileUrl": "https://www.tiktok.com/@nike",
    "displayName": "Nike",
    "followers": null,
    "error": null,
    "checkedAt": "2026-08-21T10:14:02.118Z"
}
```

A `domain_check` row per name per extension:

```json
{
    "entityType": "domain_check",
    "name": "nike",
    "tld": "com",
    "domain": "nike.com",
    "isAvailable": false,
    "registrar": "MarkMonitor Inc.",
    "registeredAt": "1995-04-07T04:00:00Z",
    "expiresAt": "2027-04-08T04:00:00Z",
    "error": null
}
```

A `summary` row per name:

```json
{
    "entityType": "summary",
    "name": "mybrandidea2026x",
    "checksRun": 11,
    "availableCount": 11,
    "takenCount": 0,
    "availableEverywhere": true,
    "availableOn": ["Instagram", "X (Twitter)", "TikTok", "YouTube", "Snapchat",
                    "Pinterest", "Twitch", "Discord", "GitHub",
                    "mybrandidea2026x.com", "mybrandidea2026x.io"],
    "takenOn": []
}
```

#### Data fields

| Field | Description |
|---|---|
| `name` | The normalized name that was checked |
| `platformTitle` / `domain` | What this row checked |
| `isAvailable` | `true` = free, `false` = taken, `null` = check could not complete |
| `displayName` | Profile name of the current holder, when the platform exposes it |
| `followers` | Follower count of the current holder, where available |
| `profileUrl` | Direct link to the profile |
| `registrar` / `registeredAt` / `expiresAt` | Domain ownership details for taken domains |
| `note` | Extra context, e.g. a domain held back by the registry |
| `availableEverywhere` | On summary rows: the name is free on every check that ran |
| `error` | Why a single check could not complete; other checks are unaffected |

#### Dataset views

- **All Results** — every check, one row each.
- **Name Summary** — one row per name, sorted-ready for ranking a shortlist.
- **Domains** — domain rows with registrar and expiry details.

### How much does it cost to check brand name availability?

You are charged per result. Each platform check, each domain check, and each summary row is one result.

Results per name = platforms selected + extensions selected + 1 summary row.

| Job | Results | Notes |
|---|---|---|
| 1 name, 9 platforms + 5 domains | 15 | A single full sweep |
| 20 candidate names, full sweep | 300 | Shortlist for a naming project |
| 100 generated names, 4 platforms + `.com` only | 600 | Cheap wide screen, then deep-check the winners |

Levers to keep the bill where you want it:

- **`platforms`** — deselect any platform you don't care about.
- **`domainTlds`** — check `.com` only for a first pass.
- **`checkDomains: false`** — social handles only.
- **`includeSummary: false`** — removes one result per name.

A practical workflow: screen a long list cheaply on the two platforms that matter most, then re-run the survivors on everything.

### Tips

- Screen wide first, then deep. A 4-check pass over 200 names costs far less than a 15-check pass, and most names die on the first pass anyway.
- `displayName` and `followers` tell you whether a taken handle is an active brand or a dormant account worth an outreach email.
- Names are normalized, so you can paste competitor profile URLs straight in.
- Handles are case-insensitive on these platforms, so `MyBrand` and `mybrand` return the same result and are de-duplicated automatically.
- No proxy is needed for normal use.

### FAQ

**Which platforms are covered?**
Instagram, X (Twitter), TikTok, YouTube, Snapchat, Pinterest, Twitch, Discord, and GitHub, plus domain registration checks for 15 extensions.

**How accurate is "available"?**
Availability is read live at run time from each platform's own public signal, not from a cached list. Domain results come from the official registry for that extension, and a name that looks unregistered is double-checked before it is reported as free — so registry-reserved names like `nike.site` are correctly reported as unavailable rather than free, with a note explaining why. If an extension cannot be verified at all, the row says so instead of guessing. A handle can still be blocked by a platform's own naming or trademark rules, so always try to claim it to be certain.

**Can I check numbers or names with dots and underscores?**
Yes, but each platform has its own rules about which characters it allows. A name that is invalid on a platform is reported as such on that row, and the other checks continue normally.

**Why does one row show an error while the rest are fine?**
Each check is independent. If one platform is briefly unreachable or rate limits a request, only that row carries the message — the rest of the run is unaffected. Re-run just those names to fill the gaps.

**Which domain extensions are supported?**
15 extensions are offered out of the box, covering the registries that publish authoritative registration data. Domain results are read from the registry responsible for that extension, not from a reseller's search page.

**Does it need a proxy?**
No. Enable one only if you check very large lists in a single run.

**Is this legal?**
The Actor reads only publicly visible availability information — the same thing you would see by typing the name into each site's signup form. You are responsible for how you use the results, including trademark clearance, which this Actor does not perform.

### Support

Want another platform added, or a different set of extensions? Open an issue on the Actor's **Issues** tab. Custom availability checks are available on request.

# Actor input Schema

## `names` (type: `array`):

The brand names or handles you want to check. Paste a bare name, an @handle, or a profile URL — all are accepted. Each name is checked against every platform and domain extension you select below.

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

Which platforms to check each name against. Every platform you select is one result per name.

## `checkDomains` (type: `boolean`):

Also check whether the matching domain names are registered. Turn this off to check social handles only.

## `domainTlds` (type: `array`):

Which domain extensions to check for each name. Each extension is one result per name. Ignored when domain checking is turned off.

## `includeSummary` (type: `boolean`):

Add one summary result per name listing where it is free and where it is taken. Handy for ranking a shortlist of candidate names.

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

Optional proxy settings. Not required for normal use — enable only if you check very large name lists and start seeing rate limiting.

## Actor input object example

```json
{
  "names": [
    "nike",
    "mybrandidea2026"
  ],
  "platforms": [
    "instagram",
    "x",
    "tiktok",
    "youtube",
    "snapchat",
    "pinterest",
    "twitch",
    "discord",
    "github"
  ],
  "checkDomains": true,
  "domainTlds": [
    "com",
    "net",
    "org",
    "io",
    "co"
  ],
  "includeSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "names": [
        "nike",
        "mybrandidea2026"
    ],
    "platforms": [
        "instagram",
        "x",
        "tiktok",
        "youtube",
        "snapchat",
        "pinterest",
        "twitch",
        "discord",
        "github"
    ],
    "domainTlds": [
        "com",
        "net",
        "org",
        "io",
        "co"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/brand-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 = {
    "names": [
        "nike",
        "mybrandidea2026",
    ],
    "platforms": [
        "instagram",
        "x",
        "tiktok",
        "youtube",
        "snapchat",
        "pinterest",
        "twitch",
        "discord",
        "github",
    ],
    "domainTlds": [
        "com",
        "net",
        "org",
        "io",
        "co",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maged120/brand-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 '{
  "names": [
    "nike",
    "mybrandidea2026"
  ],
  "platforms": [
    "instagram",
    "x",
    "tiktok",
    "youtube",
    "snapchat",
    "pinterest",
    "twitch",
    "discord",
    "github"
  ],
  "domainTlds": [
    "com",
    "net",
    "org",
    "io",
    "co"
  ]
}' |
apify call maged120/brand-username-checker --silent --output-dataset

```

## MCP server setup

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