Sherlock Scraper: 2,191 of 2,208 Runs Succeeded (2026)

Each result carries 2 fields, returning a confirmed list of public social media profile URLs across 400+ platforms for every searched username. Operating without requiring logins or API keys, this Actor processes batch inputs and supports wildcard expansion to find matches on GitHub, Twitter/X, Instagram, and hundreds of other sites. Apify's free plan includes $5.00 of monthly usage, and each result costs $0.001 after that. This tool is built for security researchers and investigators who need comprehensive handle reconnaissance, and not for anyone who requires access to private accounts or verified contact details.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 5,000 results at $0.001 each before platform usage. Open Sherlock Scraper on Apify and run the prefilled example.

How reliable is Sherlock Scraper in production?

Across the last 30 days of public runs on the Apify platform, Sherlock Scraper recorded 2,208 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	2,191	99.2%
Failed	12	0.5%
Aborted by the user	5	0.2%
Timed out	0	0.0%
Total	2,208	100.0%

When scheduling automated reconnaissance, you can expect about 1 in a hundred runs to fail or time out entirely. Design your automation architecture with built-in retries, failure alerting, and smaller batch sizes to gracefully manage these occasional interruptions without losing progress.

What does it cost to run Sherlock Scraper?

Each result costs $0.001, which is $1.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $10.00 in result charges before run-start fees and platform usage. With 0.5% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The primary cost driver is the number of items in the usernames array, as result charges apply only to items written to the dataset at $0.001 per result. The cheapest way to verify output before spending is to test a single username on Apify's free plan, which covers up to 5,000 results using monthly prepaid platform usage.

How do you run Sherlock Scraper from the API?

The Actor takes a single input, usernames, and it is required. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~sherlock-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["johndoe"]}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "usernames": [
    "johndoe"
  ]
}

run = client.actor("crawlerbros~sherlock-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "usernames": [
    "johndoe"
  ]
}

const run = await client.actor('crawlerbros~sherlock-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Sherlock Scraper inputs matter, and which can you skip?

The input schema requires a single control named usernames, which takes an array of strings. Populate this array with your target handles and use the {?} wildcard to automatically expand variations.

usernames (array): List of usernames to search for across social networks. Supports wildcard expansion with {?} (e.g., 'john{?}doe' expands to 'johnadoe', 'johnbdoe', ..., 'john9doe').

What does Sherlock Scraper return?

Returned records are well-suited for mapping a digital footprint and identifying public accounts across developer and social platforms. They conspicuously do not contain private profile data, follower counts, or direct contact details.

username: String - The username that was searched
links: Array of strings - URLs of social media profiles where the username was found

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Sherlock Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Populate the usernames array with your target identifier, using the {?} wildcard if you need to test common separator variations before running a full batch.
Execute a single test run to verify that the target platform returns valid entries in the links array without triggering rate limits.
Check that the returned dataset contains the expected username string and a populated links array for every target.
Review the individual profile URLs inside the links array to filter out any false positives where platforms return error pages or parked domains.
Add additional target identifiers to the usernames array to scale up your reconnaissance across all 400+ supported networks.
Export your final dataset in JSON, CSV, or Excel format once the run completes successfully.

How do you apply it? Three worked playbooks

These are Sherlock Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: OSINT Investigations

Outcome: Discover all online accounts associated with a username

Configure: Set the usernames array to include your target handle, such as johndoe.

Working method: Run the Actor for a single target, inspect the resulting links array for active profile URLs, and expand your target list once valid accounts are confirmed.

Deliverable: A structured dataset containing the searched username and an array of verified social media profile links.

Stop condition: The run fails entirely or returns empty links arrays across all tested platforms due to network restrictions.

Use case 2: Digital Forensics

Outcome: Find accounts for security research purposes

Configure: Configure the usernames array with the subject identifier or handle variations using the {?} wildcard.

Working method: Execute the search across all 400+ supported networks, extract the resulting profile URLs, and cross-reference them against known activity logs.

Deliverable: A comprehensive list of public profile URLs linked to the target username across developer, gaming, and social platforms.

Stop condition: Target platforms begin returning platform-specific error pages instead of valid profile matches.

Use case 3: Brand Monitoring

Outcome: Track brand name usage across social networks

Configure: Provide your proprietary brand name or trademark handle in the usernames array.

Working method: Run the search periodically to capture newly registered accounts matching your brand name, comparing the output links array against your authorized property list.

Deliverable: A dataset of active profile URLs matching the brand identifier across professional and social networks.

Stop condition: The returned links array contains persistent false positives or parked domains that obscure genuine brand presence.

What breaks, and how do you design around it?

Over the last 30 days, 0.5% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

Target websites may occasionally block automated requests or return false positives for non-existent profiles. Review the resulting links array manually and use targeted wildcard expansions to isolate valid accounts.

When should you not use Sherlock Scraper?

Do not use this Actor if you need to bypass strict rate limits, authenticate into private accounts, or extract deep profile metadata like posts and follower lists. For tasks requiring advanced entity resolution and filtering out lookalike accounts or squatters, use Sherlock Pro Scraper instead. If your objective is to gather broader contact information and official web domains from a company name rather than searching usernames, use Company Domain & Social Links Finder.

What should you check before trusting the output?

Verify that the username field matches the requested search term exactly and is not null.
Check that the links array contains valid profile URLs rather than generic error pages or search redirects.
Ensure that the run did not fail due to upstream platform blocking or rate limiting on specific target sites.
Confirm that the total count of returned records matches the length of the input usernames array.
Stop scheduled runs immediately if consecutive failures indicate platform-level blocking across major networks.

None of this proves a record is correct. It gives a scheduled Sherlock Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How many social networks does Sherlock search during a run?

Sherlock searches over 400 social networks and websites, including major platforms like Twitter, Instagram, GitHub, Reddit, and TikTok. Each site is checked sequentially for the provided username during the execution of the Actor.

What is the success rate and reliability of this Actor?

Telemetry over the last 30 days shows 2,208 total runs, with 2,191 succeeding, 12 failing, and 5 aborted by users, resulting in a success rate of 99.2% and about 1 in a hundred runs failing or timing out.

Does this Actor require any login credentials or API keys?

No. Sherlock works entirely with publicly accessible information and does not require any authentication, cookies, or API keys to perform username reconnaissance across the supported platforms.

Can I search for multiple usernames in a single run?

Yes. You can add multiple usernames to the usernames array input control. Each username in the array is processed and produces a separate result item containing its own list of discovered profile URLs.

How are costs calculated for running this Actor?

Pricing is based on a run-start fee plus $0.001 per result written to the dataset, which equals $1.00 per 1,000 results. Apify's free plan includes $5.00 of monthly usage that covers up to 5,000 results.

Where to go next

When you are ready to run it, open Sherlock Scraper on Apify; the free plan covers up to 5,000 results a month.

Start with the Sherlock Scraper Actor page for the current input schema, pricing tier, and run history.

Readers running Sherlock Scraper commonly pair it with:

Sherlock Pro Scraper: 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.
Social Media Finder: Find social media profiles across 400+ platforms by username.
Company Domain & Social Links Finder: Given a company name, return the company's official website domain and its social media links (LinkedIn, X/Twitter, Facebook, Instagram, YouTube, TikTok, GitHub).
Website Contact Finder: Crawl any website and extract emails, phone numbers, and social media profiles.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-23.
Actor last updated by its maintainers on 2026-06-11.
Run outcome figures cover the 30 day public window ending 2026-09-23.
Sherlock Scraper on Apify