# Sherlock (`futurizerush/sherlock`) Actor

Sherlock — username search across 400+ social networks. Built on the open-source Sherlock project (MIT). Streaming results, dataset overview, batch usernames, per-run summary. For OSINT, brand monitoring, and identity research. (https://github.com/sherlock-project/sherlock)

- **URL**: https://apify.com/futurizerush/sherlock.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** AI, Agents, Social media
- **Stats:** 12 total users, 4 monthly users, 94.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

**Hunt down social media accounts by username across 400+ networks.** This Actor runs the open-source [Sherlock project](https://github.com/sherlock-project/sherlock) (MIT) on Apify's serverless infrastructure — no local install, no Python setup, just give it a username and get a clean dataset of every site that has a profile under that name.

> 🧭 **Looking for more?** Browse the rest of the [futurizerush Apify catalog](https://apify.com/futurizerush?fpr=rush) — 50+ Actors covering social-media scraping, lead generation, brand monitoring, and trend analysis.

### What You Get

- 👤 **Username Discovery** — Check a single username or a batch of up to 50 in one run
- 🌐 **400+ Networks Covered** — Mainstream social platforms, niche communities, gaming, art, dev, and crypto
- ✅ **Match-Only Output** — By default, only profiles that were actually found are returned (saves you from sifting through hundreds of "not found" rows)
- 🎯 **Targeted Search** — Optionally restrict the lookup to a short list of sites
- 🔗 **Direct Profile Links** — Every match includes a clickable URL to the live profile
- 📦 **Bulk-Friendly** — Process several usernames in one run with progressive results
- 📊 **Run Summary** — A per-username breakdown lands in the key-value store after every run

### Use Cases

- **OSINT & Investigations** — Map a subject's online footprint across the open web
- **Brand & Trademark Monitoring** — See where your handle is taken (or impersonated)
- **Identity Verification** — Cross-check a person's stated profiles
- **Account Audit** — Find old accounts you've forgotten about under your own handle
- **Recruiting & Sourcing** — Quickly surface a candidate's public profiles
- **Username Availability Research** — Pick a handle that's free across the platforms you care about

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `usernames` | Array of strings | Yes | The usernames to look up. Letters, digits, dot, underscore, or hyphen. Up to 50 per run. |
| `siteList` | Array of strings | No | Restrict the search to specific sites (e.g. `["GitHub", "Twitter", "Reddit"]`). Empty = check all 400+. |
| `onlyFound` | Boolean | No | When on (default), only matches are returned. Turn off to also see available, blocked, or unknown sites. |
| `includeNsfw` | Boolean | No | Include adult sites in the catalog. Off by default. |
| `timeout` | Integer | No | Per-site response timeout in seconds. Default 60. |

#### Example Input

```json
{
  "usernames": ["johndoe", "janedoe"],
  "siteList": ["GitHub", "Instagram", "Twitter"],
  "onlyFound": true,
  "includeNsfw": false
}
````

### Output

Each result describes one username found on one social network.

| Field | Description |
|---|---|
| `username` | The username that was looked up |
| `site_name` | Name of the social network |
| `site_url_user` | Direct URL to the profile that was matched |
| `site_url_main` | Homepage of the network |
| `status` | One of `claimed`, `available`, `unknown`, `illegal`, `waf` |
| `is_nsfw` | Whether the network is flagged as adult content |
| `response_time_ms` | How long the site took to answer, in milliseconds |
| `context` | Additional notes from the lookup, when available |
| `checked_at` | ISO-8601 timestamp of the check (UTC) |

#### Example Output

```json
{
  "username": "johndoe",
  "site_name": "GitHub",
  "site_url_user": "https://github.com/johndoe",
  "site_url_main": "https://github.com",
  "status": "claimed",
  "is_nsfw": false,
  "response_time_ms": 432,
  "context": null,
  "checked_at": "2026-04-26T12:34:56+00:00"
}
```

A per-run **`SUMMARY`** record is also written to the key-value store with per-username counts and totals.

### Powered by Sherlock

This Actor is a clean Apify wrapper around the open-source **[Sherlock project](https://github.com/sherlock-project/sherlock)** — the most widely used username-search tool — with batch processing, progressive streaming results, a structured dataset, and a per-run summary on top.

- **Project**: https://github.com/sherlock-project/sherlock
- **License**: MIT (commercial use permitted with attribution)

All credit for the underlying detection logic and the site catalog goes to the Sherlock project and its contributors.

> 🚀 **Want more Apify Actors?** [Explore the futurizerush catalog](https://apify.com/futurizerush?fpr=rush) — social media scrapers (Threads, TikTok, Instagram), lead generation, market research, and more.

### Notes & Limitations

- Username detection is **heuristic**. A small number of sites can return false positives (the site responds the same way for any username) or false negatives (a temporary block or rate limit). Always verify a match before acting on it.
- Some sites return `unknown` or `waf` when they are unreachable or behind anti-bot protection — these are not failures of the Actor, just sites that could not be definitively answered at the moment of the check.
- The site catalog tracks Sherlock's bundled list. New networks are added and stale ones removed in upstream releases.
- Login-walled or region-restricted profiles may not be detectable.

### FAQ

**How many sites does it check?**
Over 400 social networks, taken from the bundled Sherlock catalog.

**Can I check a single username only?**
Yes — provide a single entry in `usernames`.

**What does `status` mean?**

- `claimed` — A profile with this username exists on the site.
- `available` — The username is free on this site.
- `unknown` — The site could not be queried reliably.
- `illegal` — The username is not allowed by the site's own format rules.
- `waf` — The site responded with an anti-bot challenge.

**Why does the same username sometimes give different results?**
Sites change their detection signals, deploy anti-bot challenges, or rate-limit clients. Re-running can give a cleaner answer.

**Does it support proxies or Tor?**
Not in this version. Direct connections work for most lookups.

**Can I add my own sites?**
Not in this version. The catalog comes from the upstream Sherlock release.

### Disclaimer

This Actor is intended for **educational, research, and lawful identity-verification purposes only**. By using it you agree to:

- Use the data responsibly and in compliance with applicable laws and platform Terms of Service
- Not use the results for harassment, doxxing, stalking, or any unauthorized commercial purpose
- Verify any match before acting on it — username detection is heuristic and can be wrong
- Take full responsibility for how the data is used

The developer is not affiliated with Sherlock or any of the social networks listed and is not responsible for any misuse of this tool or the data it returns.

### Support

For questions or issues, please reach out through Apify support.

If you find this Actor useful, you can support it (and the broader futurizerush catalog) by browsing through [this affiliate link](https://apify.com/futurizerush?fpr=rush).

### License & Attribution

This Actor wraps the open-source [Sherlock project](https://github.com/sherlock-project/sherlock) (PyPI package `sherlock-project`, version 0.16.0), which is distributed under the **MIT License**. The license text and copyright notice are reproduced below in compliance with its redistribution terms:

```
MIT License

Copyright (c) 2019 Sherlock Project

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

A canonical machine-readable copy is also bundled with this Actor as `THIRD-PARTY-LICENSES.md`.

***

*Sherlock · username search · social media username checker · OSINT tool · profile finder · username availability · online presence audit · brand handle monitoring · identity verification · social network lookup · open-source intelligence · OpenClaw · Claude Code · Gemini · Antigravity · Codex · ChatGPT · Apify Skills*

# Actor input Schema

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

Enter the usernames to look up. Use letters, digits, dot, underscore, or hyphen (1–50 characters).

## `siteList` (type: `array`):

Restrict the search to a few specific sites — for example: GitHub, Instagram, Twitter, Facebook, TikTok, YouTube, Reddit, Twitch, Spotify, Steam, Medium, GitLab, Telegram, Mastodon, Bluesky. Leave empty to check the full catalog of 400+ networks. Names are case-insensitive.

## `onlyFound` (type: `boolean`):

When enabled, the dataset only contains profiles that were detected as claimed. Turn it off to include sites where the username is available, blocked, or returned no clear answer.

## `includeNsfw` (type: `boolean`):

Include sites flagged as adult content in the catalog. Disabled by default.

## `timeout` (type: `integer`):

Maximum time to wait for each individual site to respond. Lower values speed up the run but may miss slow sites.

## Actor input object example

```json
{
  "usernames": [
    "johndoe"
  ],
  "siteList": [],
  "onlyFound": true,
  "includeNsfw": false,
  "timeout": 60
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `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": [
        "johndoe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/sherlock").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": ["johndoe"] }

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/sherlock").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 '{
  "usernames": [
    "johndoe"
  ]
}' |
apify call futurizerush/sherlock --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sherlock",
        "description": "Sherlock — username search across 400+ social networks. Built on the open-source Sherlock project (MIT). Streaming results, dataset overview, batch usernames, per-run summary. For OSINT, brand monitoring, and identity research. (https://github.com/sherlock-project/sherlock)",
        "version": "0.0",
        "x-build-id": "u6sVrKC4JjevTb07N"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~sherlock/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-sherlock",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/futurizerush~sherlock/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-sherlock",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/futurizerush~sherlock/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-sherlock",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "👤 Usernames",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Enter the usernames to look up. Use letters, digits, dot, underscore, or hyphen (1–50 characters).",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9._-]{1,50}$"
                        }
                    },
                    "siteList": {
                        "title": "🎯 Limit to specific sites (optional)",
                        "type": "array",
                        "description": "Restrict the search to a few specific sites — for example: GitHub, Instagram, Twitter, Facebook, TikTok, YouTube, Reddit, Twitch, Spotify, Steam, Medium, GitLab, Telegram, Mastodon, Bluesky. Leave empty to check the full catalog of 400+ networks. Names are case-insensitive.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "onlyFound": {
                        "title": "✅ Only return matches that were found",
                        "type": "boolean",
                        "description": "When enabled, the dataset only contains profiles that were detected as claimed. Turn it off to include sites where the username is available, blocked, or returned no clear answer.",
                        "default": true
                    },
                    "includeNsfw": {
                        "title": "🔞 Include adult sites",
                        "type": "boolean",
                        "description": "Include sites flagged as adult content in the catalog. Disabled by default.",
                        "default": false
                    },
                    "timeout": {
                        "title": "⏱️ Per-site timeout (seconds)",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time to wait for each individual site to respond. Lower values speed up the run but may miss slow sites.",
                        "default": 60
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
