# Sherlock Pro Scraper (`crawlerbros/sherlock-pro-scraper`) Actor

Search for usernames across 400+ social networks, narrow results down to just the platforms you care about, and uniquely figure out which account on a target platform actually belongs to a known profile, even when squatters and lookalike accounts are in the way.

- **URL**: https://apify.com/crawlerbros/sherlock-pro-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 3 total users, 1 monthly users, 95.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/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

## Sherlock Pro — Username Search & Identity Resolution

Search for usernames across **400+ social networks**, narrow results down to just the platforms you care about, and — uniquely — figure out **which account on a target platform actually belongs to a known profile**, even when squatters and lookalike accounts are in the way.

### What this actor does

- **Search 400+ social networks** in a single run, or filter down to just the ones you need via a dropdown of every supported network
- **Batch processing** — search multiple usernames at once, with `{?}` wildcard expansion for username variations (e.g. `john{?}doe` → `john_doe`, `john-doe`, `john.doe`)
- **Identity resolution** — give it a known account on one platform and a target network, and it either auto-discovers or verifies candidate accounts there, ranking each by a transparent, multi-signal confidence score (bio backlink, display-name/avatar similarity, verified badge, follower count, username similarity) — never a black-box match
- **Honest "no match" reporting** — if no candidate clears the confidence bar, the actor says so instead of guessing
- **Empty fields are omitted** — no `null`, no placeholders; every field present is real data
- **No login required** — works entirely with publicly available information

### Output

#### Broad Search (mode = `broadSearch`)

- `username` — the username that was searched
- `links[]` — URLs of profiles where the username was found (omitted entirely if none found)

#### Identity Resolution (mode = `identityResolution`)

One record per target network:

- `sourceProfile` — the known account being resolved against, with any enrichment found: `platform`, `handle`, `profileUrl`, `displayName`, `verified`
- `targetNetwork` — the network this record's candidates were evaluated on
- `candidateMode` — `discover` or `verify`
- `candidatesEvaluated` — how many candidates were scored
- `bestMatch` — the highest-confidence candidate (handle, profileUrl, confidenceScore, confidenceLabel, signals) — omitted entirely if none clears the confidence bar
- `candidates[]` — every scored candidate, ranked by confidence, each with its own `signals` breakdown
- `warnings[]` — non-fatal notes (e.g. a signal couldn't be computed, or auto-discovery isn't supported for this network) — omitted if empty

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `broadSearch` | `broadSearch` or `identityResolution` |
| `usernames` | array | `["johndoe"]` | Usernames to search (mode=broadSearch). Supports `{?}` wildcard. |
| `targetNetworks` | array | `["GitHub"]` | Networks to limit the search/resolution to — dropdown of every supported network. Optional filter in broadSearch (omit to search all 400+); required (1+) in identityResolution; exactly one required when `candidateMode` is `verify`. |
| `sourceProfile` | object | `{"platform": "instagram", "handle": "xyz"}` | The known account to resolve against — `{platform, handle}` (mode=identityResolution) |
| `sourceOverrides` | object | – | Manual `displayName`/`bio`/`avatarUrl` for the source, used when the source platform can't be auto-read or to supplement missing data (mode=identityResolution) |
| `candidateMode` | string | `discover` | `discover` — auto-find candidates via search + username-variation heuristics; `verify` — score only the handles you supply (mode=identityResolution) |
| `candidateHandles` | array | – | Candidate handles to score (required when `candidateMode` is `verify`) |
| `maxCandidatesToDiscover` | integer | `20` | Caps how many candidates `discover` mode generates/searches (1–60) |

#### Example: filter Broad Search to specific networks

```json
{
  "mode": "broadSearch",
  "usernames": ["johndoe"],
  "targetNetworks": ["GitHub", "YouTube"]
}
```

#### Example: discover the real account on a target network

```json
{
  "mode": "identityResolution",
  "sourceProfile": { "platform": "instagram", "handle": "xyz" },
  "targetNetworks": ["GitHub"],
  "candidateMode": "discover",
  "maxCandidatesToDiscover": 20
}
```

#### Example: verify a shortlist of suspects

```json
{
  "mode": "identityResolution",
  "sourceProfile": { "platform": "github", "handle": "torvalds" },
  "targetNetworks": ["TikTok"],
  "candidateMode": "verify",
  "candidateHandles": ["torvalds", "torvalds_official", "real_torvalds"]
}
```

#### Example: batch username search with wildcard expansion

```json
{
  "mode": "broadSearch",
  "usernames": ["john{?}doe", "janedoe"],
  "targetNetworks": ["GitHub", "Reddit", "Twitter"]
}
```

### Use Cases

- **Influencer verification** — confirm which TikTok/Instagram/Twitter account genuinely belongs to a known creator before running a partnership or ad spend
- **Brand protection** — find squatter and impersonator accounts across networks and see exactly why they were flagged as low-confidence
- **OSINT investigations** — discover all online accounts associated with a username, filtered to the networks that matter for the case
- **Digital forensics** — cross-reference identity signals across platforms with a transparent, auditable trail
- **Recruiting / vendor vetting** — cross-check a candidate's or vendor's professional and social presence before engaging

### FAQ

#### Can I limit results to just the networks I care about?

Yes. Set `targetNetworks` in `broadSearch` mode (e.g. `["TikTok", "Instagram"]`) — pick from the dropdown of every supported network — and only those sites are checked, so you don't pay for or wait on the other 400+. `identityResolution` mode additionally accepts `Reddit` as a target since it resolves candidates through Reddit's own public search API rather than Sherlock's site list.

#### How does it tell the real account apart from fake/lookalike accounts?

This is what `identityResolution` mode is for. Given a known source profile, it finds candidate accounts on the target network (either by searching the platform directly or by generating and existence-checking common username variants like numeric suffixes and "official"/"real" patterns), then scores every candidate on independent signals: whether the candidate's bio links back to the source account, how similar the display names are, how similar the profile pictures are, verified-badge status, relative follower count, and username similarity (case-insensitive). The scores are weighted so that bio backlinks and display-name/avatar similarity — signals fakes rarely have — count far more than raw username similarity, which is exactly what squatter accounts (`xyz0`, `xyz1`, `xyz2`) try to exploit. A bio backlink only ever *helps* a candidate when found — a real profile whose bio simply doesn't mention the source platform (common; most people don't cross-link everywhere) is never penalized for it. The full signal breakdown is always included so you can see exactly why a candidate was or wasn't picked. If no candidate is confidently the real account, the actor reports that honestly instead of guessing.

#### What if I already know the suspect accounts and just want them ranked?

Use `candidateMode: "verify"` with `candidateHandles` set to your list of suspects and a single `targetNetworks` entry. The actor skips discovery and scores exactly those candidates.

#### Why is auto-discovery unavailable for some networks?

TikTok's public existence-check reports every handle — including random strings — as "existing," so auto-generated candidates there would be fabricated rather than real. Auto-discovery (`candidateMode: "discover"`) is disabled specifically for TikTok for this reason; `candidateMode: "verify"` still works fully, with the same transparent scoring, once you supply your own candidate list.

#### How many social networks does it search?

Broad Search covers the same 400+ platforms as the original Sherlock — GitHub, Twitter/X, Instagram, Reddit, TikTok, LinkedIn, YouTube, and hundreds more.

#### Does it find private or deleted accounts?

No. Only publicly accessible profiles are checked — private, deleted, or restricted-visibility accounts won't appear.

#### What does the `{?}` wildcard do?

Expands a username into three variations using common separators: `_`, `-`, and `.`. For example, `john{?}doe` searches `john_doe`, `john-doe`, and `john.doe`.

#### Does this require a login or API key?

No. Everything works with publicly accessible information — no authentication, cookies, or API keys required.

#### Can false positives occur?

Yes, occasionally — on both Broad Search (a site may report a username as existing when the page is actually an error page) and Identity Resolution (signals can be sparse for platforms that block scraping, e.g. Twitter/X, lowering confidence). Always review the `signals` breakdown before treating a match as certain.

#### Is this affiliated with any of the platforms it searches?

No. This is an independent, third-party actor using only publicly accessible information; it is not affiliated with GitHub, Reddit, TikTok, Instagram, Twitter/X, LinkedIn, YouTube, or any other platform it searches.

#### What output formats are available?

Results can be exported as JSON, CSV, Excel (XLSX), HTML, RSS, or XML directly from the Apify platform.

# Actor input Schema

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

broadSearch: check usernames across networks (optionally filtered). identityResolution: disambiguate which candidate account on a target network matches a source profile.

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

Usernames to search for (broadSearch mode). Supports {?} wildcard (e.g. 'john{?}doe' expands to 'john\_doe', 'john-doe', 'john.doe').

## `targetNetworks` (type: `array`):

Limit the search/resolution to these networks. Optional filter in broadSearch (omit to search all 400+). Required (1+) in identityResolution; exactly one network required when candidateMode is 'verify'. The list covers every network Sherlock supports plus Reddit (resolved via its own public search API for identityResolution).

## `sourceProfile` (type: `object`):

The known account to resolve against (identityResolution mode). Example: {"platform": "instagram", "handle": "xyz"}.

## `sourceOverrides` (type: `object`):

Optional manual displayName/bio/avatarUrl for the source profile, used when the source platform can't be auto-scraped (e.g. Instagram) or to supplement missing data.

## `candidateMode` (type: `string`):

discover: auto-generate candidates via search + username-variation heuristics. verify: score only the candidateHandles you supply.

## `candidateHandles` (type: `array`):

Handles to verify against the source profile on the single target network (required when candidateMode is 'verify').

## `maxCandidatesToDiscover` (type: `integer`):

Upper bound on generated/searched candidates per target network in discover mode.

## Actor input object example

```json
{
  "mode": "broadSearch",
  "usernames": [
    "johndoe"
  ],
  "targetNetworks": [
    "GitHub"
  ],
  "sourceProfile": {
    "platform": "instagram",
    "handle": "xyz"
  },
  "candidateMode": "discover",
  "maxCandidatesToDiscover": 20
}
```

# Actor output Schema

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

Dataset containing all username search and identity resolution results.

# 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": "broadSearch",
    "usernames": [
        "johndoe"
    ],
    "targetNetworks": [
        "GitHub"
    ],
    "sourceProfile": {
        "platform": "instagram",
        "handle": "xyz"
    },
    "candidateMode": "discover",
    "maxCandidatesToDiscover": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/sherlock-pro-scraper").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": "broadSearch",
    "usernames": ["johndoe"],
    "targetNetworks": ["GitHub"],
    "sourceProfile": {
        "platform": "instagram",
        "handle": "xyz",
    },
    "candidateMode": "discover",
    "maxCandidatesToDiscover": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/sherlock-pro-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "broadSearch",
  "usernames": [
    "johndoe"
  ],
  "targetNetworks": [
    "GitHub"
  ],
  "sourceProfile": {
    "platform": "instagram",
    "handle": "xyz"
  },
  "candidateMode": "discover",
  "maxCandidatesToDiscover": 20
}' |
apify call crawlerbros/sherlock-pro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/sherlock-pro-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fY077fzGnFGcfEb4Z/builds/K7bc0JqSIn7h6bAa9/openapi.json