Sherlock Username OSINT - 480+ Site Account Finder

This Apify Actor accepts one or more plain usernames and scans Sherlock's current 481-entry catalog to find where each handle is registered. The default scan checks 462 non-NSFW entries; enabling includeNSFW adds the 19 adult-oriented entries. Each input username produces one dataset item, so one record means one scanned handle and its per-platform results. The record includes timestamps, checked and targeted counts, confirmed CLAIMED profiles, uncertain WAF/timeout results, and a per-platform list with status, public URL, and detection method. It is usable through Apify and Apify MCP, with one predictable username-scan event per accepted username.

Best fit and connected workflows

This Actor fits workflows that start with a username and need a public footprint map across social, dev, gaming, forum, media, business, and related sites.

Good routing patterns include:

• public identity research from a known handle
• brand monitoring for username reuse across multiple site groups
• availability checks before reserving a handle on several platforms
• fraud, trust, and safety triage where a cross-platform account map helps review
• downstream enrichment that begins with confirmed public profile URLs and continues into profile detail scrapers, contact extraction, or manual review

The output is especially useful when a workflow needs to confirm public profile URLs first, then pass those URLs into downstream review, enrichment, or monitoring steps.

When to use this Actor

Use this Actor when you have one or more public usernames and need a structured cross-site account map before a human review or a downstream profile-enrichment step. Choose a different workflow when your starting identifier is an email address, when the target data requires authentication, or when you need to prove account ownership. The Actor is scoped to public profile checks; private-account access, credential discovery, and access-control bypass are outside this workflow.

Practical scenario

Nina is reviewing a creator handle that appears on GitHub, Reddit, and a video platform. She enters the username as a plain handle and keeps includeAvailable off because she only needs registered profiles. The Actor returns platformsFound, platformsChecked, and a platforms[] list with site names, categories, URLs, and detection methods. Nina uses the claimed profile URLs to decide which accounts to inspect next and which ones to send into a separate enrichment workflow.

Input fields

Field	Type	Default	Description
usernames	string[]	Required	One or more plain handles to scan. Each username triggers one sequential scan with parallel site requests and one billable event. Max 100 usernames per run. A leading @ is accepted; URLs, email addresses, spaces, and path/query characters are rejected.
includeAvailable	boolean	false	Includes platforms where the username is available, alongside claimed profiles. Useful when checking availability before registering on multiple platforms.
includeNSFW	boolean	false	Includes adult-oriented sites in the scan when enabled. Useful for compliance, brand-protection, or fraud-investigation workflows where adult-site presence matters.
categories	string[]	[]	Limits the scan to selected site groups such as social, dev, gaming, forum, media, business, or other. Empty array scans the full 462-entry non-NSFW set, or all 481 entries with includeNSFW.
concurrency	integer	40	Number of parallel HTTP requests across the site list. Higher values increase speed and memory use.
requestTimeoutSecs	integer	15	Maximum seconds to wait for one site response before the site is marked as timed out.
proxyConfiguration	object	Apify residential proxies	Apify proxy settings for the scan. Residential proxy groups are prefilled in the live contract.

Focused JSON example

{
  "usernames": ["khadinakbar", "gvanrossum"],
  "includeAvailable": false,
  "includeNSFW": false,
  "categories": ["dev"],
  "concurrency": 40,
  "requestTimeoutSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Output fields

Field	Type	Description
username	string	The username that was scanned.
scanStartedAt	string	ISO 8601 timestamp for when the scan started.
platformsChecked	integer	Number of platforms actually checked for this username.
platformsTargeted	integer	Number of platforms selected by the input filters before timeout-aware early stopping.
platformsFound	integer	Number of platforms where the username is registered.
platformsBlocked	integer	Number of platforms whose response was protected by anti-bot controls or remained uncertain because of a transient response.
scanDurationMs	integer	Total scan duration in milliseconds.
scanIncomplete	boolean	Indicates that the scan returned partial results.
stopReason	string	Reason the scan stopped early when partial results were returned.
platforms	array	Per-platform results with site, category, URL, status, detection method, HTTP status, NSFW flag, and an uncertainty reason when applicable.
blocked	array	Sites where the response was protected by anti-bot controls or remained uncertain; these rows represent review candidates rather than confirmed accounts.
_note	string	Human-readable scan summary.

Illustrative JSON record

{
  "username": "gvanrossum",
  "scanStartedAt": "ISO_8601_SCAN_TIMESTAMP",
  "platformsChecked": 481,
  "platformsTargeted": 481,
  "platformsFound": 23,
  "platformsBlocked": 4,
  "scanDurationMs": 27310,
  "scanIncomplete": false,
  "stopReason": "",
  "platforms": [
    {
      "site": "GitHub",
      "category": "dev",
      "url": "https://www.github.com/gvanrossum",
      "status": "CLAIMED",
      "detectionMethod": "status_code",
      "httpStatus": 200,
      "isNSFW": false
    },
    {
      "site": "Hugging Face",
      "category": "dev",
      "url": "https://huggingface.co/gvanrossum",
      "status": "CLAIMED",
      "detectionMethod": "status_code",
      "httpStatus": 200,
      "isNSFW": false
    }
  ],
  "blocked": [
    {
      "site": "Instagram",
      "url": "https://instagram.com/gvanrossum",
      "reason": "WAF-Cloudflare"
    }
  ],
  "_note": "23 platforms found. 481 checked. 4 protected or timed-out responses."
}

How it works

This Actor uses Sherlock's site catalogue and three-mode detection model:

• status_code for sites where the HTTP status distinguishes existing and missing profiles
• message for sites that return a page body with a profile-existence message
• response_url for sites that redirect missing handles and can be checked by the final URL

The scan supports category filters, optional NSFW coverage, and per-request timeouts. Anti-bot challenges, rate limits, server-side responses, and network failures remain WAF or UNKNOWN instead of being reported as confirmed accounts. The execution contract also writes OUTPUT, RUN_SUMMARY, and SUMMARY records for machine-readable outcome and terminal details.

Pricing

This Actor uses Pay per event plus Apify platform usage. The primary event is Username scanned across 481 Sherlock sites, priced at $0.04 per accepted username and charged once for each username processed across the selected site set. Apify platform usage is billed separately according to your runtime and account settings.

Worked example: if you scan two usernames, the Actor charges two username-scan events (2 × $0.04 = $0.08) and returns 2 results (one dataset row per username); Apify platform usage is then applied for the compute used during the run. For current billing details, open the live Pricing tab in Apify Console.

Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. It accepts usernames, scans the configured site catalogue, and returns structured dataset items that agents can route into follow-up analysis.

Tool description: scan one or more usernames across Sherlock's 481-site catalog and return confirmed profile URLs, per-platform status, detection methods, WAF/unknown details, and run summary fields at a predictable per-username charge.

Exact Actor identity: khadinakbar/username-osint-scraper

Scan the username khadinakbar and return claimed public profiles, protected or timed-out responses, and a short summary. Then extract the GitHub and Reddit URLs for manual review.

How to interpret the output:

• CLAIMED means the username is registered on that platform
• AVAILABLE appears when includeAvailable is enabled
• WAF marks a response protected by anti-bot controls
• UNKNOWN marks a network issue, timeout, rate limit, server-side response, or access challenge
• platformsFound, platformsBlocked, and scanIncomplete help agents judge how much of the catalogue was completed

Provenance and scope:

• each dataset item represents one scanned username
• platforms[] contains the per-platform evidence behind the summary fields
• blocked[] captures sites where a reliable status remains to be established
• results are based on public profile URLs and platform responses only

Pagination and cost guidance:

• scan one username per agent step when you want simple charge accounting
• use categories to narrow the site set when the workflow only needs a subset such as dev or social
• each username in the input array is one billable event

Apify API example

import { ApifyClient } from "apify-client";

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor("khadinakbar/username-osint-scraper").call({
  usernames: ["khadinakbar", "gvanrossum"],
  categories: ["dev"],
  includeAvailable: false,
  includeNSFW: false,
  concurrency: 40,
  requestTimeoutSecs: 15,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Best results and outcome guidance

Use plain usernames only; a leading @ is accepted, while full URLs, email addresses, spaces, and path/query characters are rejected. Start with one handle per run when you want straightforward charge accounting and easy review, then expand to batches when your workflow is ready for multiple identities. Use categories to focus the scan on the site groups that match your task, and enable includeAvailable when availability coverage is part of the goal. For public-profile review, treat only CLAIMED URLs as confirmed handoff points; review WAF and UNKNOWN rows separately.

Focused standalone workflow

This Actor is designed as a focused standalone workflow.

Design note

I found that the output contract requires username, platformsChecked, platformsFound, and platforms on every dataset item, which keeps the main scan record compact while still carrying the per-platform evidence.

FAQ

Can I scan more than one username in a single run?

Yes. The usernames field accepts an array of up to 100 plain handles, and each username is processed as its own scan item.

What kind of result should I expect for a standard OSINT workflow?

The default output centers on CLAIMED results, plus protected or uncertain responses in blocked[] and platformsBlocked. If you enable includeAvailable, the Actor also returns AVAILABLE entries for availability checks, while WAF and UNKNOWN remain explicitly uncertain.

How should I route a handle into another workflow?

Use the URLs in platforms[] to hand off confirmed public profiles to downstream enrichment Actors, review steps, or monitoring tools. The categories help you isolate relevant platforms before that handoff.

How do I work with protected or timeout-heavy sites?

Review blocked[] and platformsBlocked together. These fields show which platforms returned protected or incomplete responses, which helps an agent decide whether to retry with different filters or move forward with the confirmed hits.

Why use categories at all?

Categories let you focus on a subset such as dev or social when a workflow only needs a specific platform group. Leaving categories empty scans the full catalogue.

Scope and legal boundary

Use this Actor for legitimate public-profile research, brand protection, fraud detection, recruiting, journalism, and similar workflows. The Actor checks public profile URLs and records platform responses for the usernames you provide. Respect applicable privacy laws, platform terms, and your own organizational policies when using the returned data.