# Username Lookup Across 400+ Social Platforms (`nimbryxo-studio/username-lookup-across-400-plus-social-platforms`) Actor

Check a username or nickname against 400+ social, gaming, professional and messaging platforms and get back the public profiles confirmed to exist for it.

- **URL**: https://apify.com/nimbryxo-studio/username-lookup-across-400-plus-social-platforms.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Verified Username Lookup Across Social Platforms

Most username checkers answer one question with one bit: "found" or "not found". That bit is often wrong, because a login wall, a Cloudflare challenge, an empty app shell and a soft-404 all return HTTP 200. This actor answers the question honestly: it checks a handle against **29 platforms that passed a known-handle plus random-handle validation gate**, and it labels every answer with `status`, `confidence` and `evidence`. When a platform blocks, logs out or returns an ambiguous page, the row says `unknown` instead of pretending the handle is free.

### What it does

- **Lookup**: check one or many handles, `@handles` or profile URLs. Found profiles are returned with the canonical profile URL, HTTP status, confidence and an evidence label. Blocked or ambiguous checks are returned as `unknown`.
- **Availability**: get one row per platform with `availability` = `available`, `taken` or `unknown`. This is the mode to use before choosing a new handle.
- **Name search**: turn a full name into up to 10 handle candidates (`johnsmith`, `john.smith`, `john_smith`, `john-smith`, `jsmith`, ...), check each candidate, and score matches using the number of platforms found plus display-name similarity.
- **Verified coverage**: 29 platforms with hard status or positive content-signature rules, validated against real control handles and cryptographic random handles with zero false positives in the discovery run.
- **Extended coverage**: an optional 400+ platform catalogue. Extended rows are always `confidence: low`, use a best-effort status check, and never contaminate the verified result set silently.
- **No cookies, accounts or API keys.** All checks are direct requests to public profile URLs or public JSON/oEmbed/XML/RSS endpoints.

### Why the status matters

| Status | Meaning |
|---|---|
| `found` | The platform returned a hard positive signal: 200 with a profile signature, JSON profile, oEmbed payload, RSS feed or XML profile. |
| `not_found` | The platform returned a hard negative: 404/410, JSON 404/400, oEmbed 400, "no such user", or an explicit not-found body. |
| `unknown` | The platform blocked us, returned a challenge/login page, rate-limited, timed out, or answered with a page that cannot prove either existence or absence. `exists` is omitted. |

An `unknown` row is **not** proof that the handle is available. It means the actor could not check that platform reliably at that moment. Re-run later, lower concurrency, or check that platform manually.

### Output fields

Each profile/check row contains:

- `recordType` — `profile` or `summary`
- `query` — the handle or full name you asked for
- `username` — the checked handle (the candidate handle in name search)
- `platform`, `platformId`, `category`
- `url` — the canonical profile URL
- `exists` — `true` for found, `false` for a hard not-found; omitted for `unknown`
- `availability` — `taken`, `available` or `unknown` in availability mode
- `status` — `found`, `not_found` or `unknown`
- `statusReason` — present for `unknown` rows, e.g. `cloudflare_challenge`, `login_wall`, `rate_limited`, `timeout`, `soft_404`
- `confidence` — `high`, `medium` or `low`
- `evidence` — how the verdict was reached, e.g. `http_200`, `json_200`, `oembed_author`, `embed_followers`, `rss_200`, `xml_profile`
- `httpStatus`, `responseTimeMs`
- `displayName`, `bio`, `avatarUrl` — when the platform exposes them
- `candidate`, `matchScore` — name-search rows only

Every run also emits one `summary` record with counts (`profilesFound`, `notFound`, `unknown`, `available`, `taken`), `queriesChecked`, `platformsChecked`, `rows`, `durationSecs`, `status` and any ignored platform names.

Empty fields are omitted everywhere. There are no `null`, `""`, `[]` or `{}` values in the dataset.

### Inputs

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | select | `lookup` | `lookup`, `availability` or `name_search`. |
| `usernames` | array | — | Handles, `@handles` or profile URLs. Required for lookup/availability. |
| `names` | array | — | Full names for name search. |
| `coverage` | select | `verified` | `verified` (29 platforms) or `extended` (400+ best-effort platforms). |
| `platforms` | multi-select | — | Leave empty for all platforms in the chosen coverage. |
| `maxConcurrency` | integer | `12` | 1–12. The discovery run validated 12 as the safe default. |
| `maxResults` | integer | `500` | 1–5,000 profile/check rows. The summary is extra. |
| `proxyConfiguration` | object | — | Optional. The actor works with no proxy. |

Caps: 50 queries per run (10 when extended coverage is active), 10 name candidates per name, 5,000 rows. Duplicate queries, candidates and platform checks are de-duplicated before any request is made.

### Example: lookup one handle on the verified set

```json
{
  "mode": "lookup",
  "usernames": ["torvalds"],
  "coverage": "verified",
  "maxResults": 50
}
```

### Example: check whether a handle is free

```json
{
  "mode": "availability",
  "usernames": ["mynewbrand"],
  "platforms": ["GitHub", "YouTube", "TikTok", "Instagram", "Pinterest", "X/Twitter", "Bluesky"],
  "maxResults": 50
}
```

### Example: find profiles from a full name

```json
{
  "mode": "name_search",
  "names": ["Linus Torvalds"],
  "platforms": ["GitHub", "Bluesky", "Mastodon.social"],
  "maxResults": 100
}
```

### Coverage tiers

**Verified (29):** GitHub, GitLab, YouTube, TikTok, Instagram, Pinterest, Twitch, X/Twitter, Medium, SoundCloud, Steam, Snapchat, Bluesky, Mastodon.social, Threads, Dribbble, Behance, Vimeo, Keybase, Substack, Flickr, HackerNews, Dev.to, HuggingFace, Chess.com, Lichess, Goodreads, Patreon, About.me.

These platforms were tested with real control handles and three cryptographic random handles each. The validated set returned **71/74 control handles found (96%)**, **0/87 random handles found (0% false positives)** and only 4 unknown results. One username across all 29 took about 3.8 seconds at 12-way concurrency.

**Extended (400+):** pulled from the public Sherlock site catalogue after removing known soft-404 traps, login-walled platforms, dead domains and adult sites. Extended checks use a status-only rule and are always `confidence: low`. Treat them as leads, not proof.

### What is deliberately excluded

Reddit, LinkedIn, Facebook, Telegram, VK, npm, Letterboxd, Untappd, Rumble, Linktree, Ko-fi, ProductHunt, Quora, AllMyLinks, BabyRu, Tumblr, Codeberg and osu! were blocked, login-walled or timed out during discovery. PyPI, Last.fm, Trakt, eBay, Odysee, Dailymotion, Spotify and F3.cool return 200 for random handles and are excluded from the verified set. If a platform becomes reliably checkable without cookies, it can be added to a future verified registry.

### FAQ

**Do I need cookies, an account or an API key?**
No. The actor uses only public pages and public JSON/oEmbed/XML/RSS endpoints. It never asks for platform credentials.

**Do I need a proxy?**
No. The verified set works without one. You can attach an Apify proxy configuration if you want requests routed through it, but it is not required.

**Why is a platform `unknown` instead of `not_found`?**
Because the platform blocked the request, showed a challenge/login page, rate-limited, timed out, or returned a page that proves nothing. The actor refuses to turn that into a false "available" answer.

**Why does a live profile sometimes belong to a different person?**
A handle is not an identity. The same handle can be registered by someone else on another platform. `displayName` and `bio` are provided to help you disambiguate, but you should verify identity yourself.

**How does name search score matches?**
Each candidate is checked on the selected platforms. The score combines the share of platforms where the candidate exists (60%) with the best display-name token overlap against the searched name (40%). A candidate with no found profiles is not emitted.

**What happens when nothing is found?**
The run succeeds and emits a summary row with `status: no_results`. It does not fail the run.

**How are retries handled?**
HTTP 419, 429, 5xx and timeouts are retried twice with exponential backoff and jitter. A failed check after retries becomes `unknown`, never `not_found`.

**Is this affiliated with the platforms?**
No. This is an independent actor that checks publicly accessible profile pages.

# Actor input Schema

## `mode` (type: `string`):

lookup returns found profiles (plus blocked/unknown checks), availability returns one row per platform with available/taken/unknown, and name_search generates handle candidates from a full name.

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

Handles to check. Accepts plain handles, @handles and profile URLs. Required for lookup and availability. Maximum 50 per run (10 when extended coverage is active).

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

Full names for name_search. The actor builds up to 10 handle candidates per name, checks them, and scores the matches. Maximum 50 per run.

## `coverage` (type: `string`):

verified uses the 29 platforms that passed a known-handle plus random-handle gate. extended adds 400+ best-effort platforms at low confidence.

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

Limit the run to specific platforms. Leave empty to use all verified platforms, or all verified + extended platforms when coverage=extended. Extended-only platform names are rejected when coverage=verified.

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

Concurrent checks. The default of 12 is the validated safe value for the verified set; per-host requests are limited further.

## `maxResults` (type: `integer`):

Maximum profile/check rows to emit. The summary row is always emitted and is not counted.

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

The actor works without a proxy. Supply one only if you want requests routed through your own Apify proxy configuration.

## Actor input object example

```json
{
  "mode": "lookup",
  "usernames": [
    "torvalds"
  ],
  "coverage": "verified",
  "platforms": [
    "GitHub",
    "YouTube",
    "TikTok",
    "Pinterest",
    "X/Twitter",
    "Bluesky",
    "Steam"
  ],
  "maxConcurrency": 12,
  "maxResults": 10
}
```

# Actor output Schema

## `profiles` (type: `string`):

Dataset containing profile/check rows and the run summary.

# 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 = {
    "mode": "lookup",
    "usernames": [
        "torvalds"
    ],
    "coverage": "verified",
    "platforms": [
        "GitHub",
        "YouTube",
        "TikTok",
        "Pinterest",
        "X/Twitter",
        "Bluesky",
        "Steam"
    ],
    "maxConcurrency": 12,
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/username-lookup-across-400-plus-social-platforms").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 = {
    "mode": "lookup",
    "usernames": ["torvalds"],
    "coverage": "verified",
    "platforms": [
        "GitHub",
        "YouTube",
        "TikTok",
        "Pinterest",
        "X/Twitter",
        "Bluesky",
        "Steam",
    ],
    "maxConcurrency": 12,
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/username-lookup-across-400-plus-social-platforms").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 '{
  "mode": "lookup",
  "usernames": [
    "torvalds"
  ],
  "coverage": "verified",
  "platforms": [
    "GitHub",
    "YouTube",
    "TikTok",
    "Pinterest",
    "X/Twitter",
    "Bluesky",
    "Steam"
  ],
  "maxConcurrency": 12,
  "maxResults": 10
}' |
apify call nimbryxo-studio/username-lookup-across-400-plus-social-platforms --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/username-lookup-across-400-plus-social-platforms"
        }
    }
}
```

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/fRGi5lHU5z5ElXvT9/builds/dMVnzw4obP65tSF3V/openapi.json