A [+] line in a Sherlock username search does not mean the account exists. It means one HTTP response from one site matched a rule in the Sherlock site manifest, and a block page, a soft 404 or a bot wall can match that rule as easily as a real profile can. On a handle we made up and never registered anywhere, Sherlock reported six or seven “found” accounts per run, and 48 once the upstream exclusion list was switched off.
This guide installs the Sherlock OSINT tool the way the project recommends, runs real searches, and then follows a few of those suspect hits back to the HTTP response that produced them. You’ll also see which export flags write files and which quietly write nothing, and what replaced the old Tor flags. Everything below was run with Sherlock 0.16.2 from pipx on Ubuntu 26.04 and 24.04, plus the Kali package in a kali-rolling container, in November 2026.
A found result is one HTTP check
Sherlock doesn’t log in anywhere or read profiles. For each of its 400+ sites it builds a URL from your username, sends one request, and applies the test that the manifest names for that site. The --dump-response output later in this guide prints that test as TEST METHOD. The source knows three types, status_code, message and response_url (which turns off redirects and wants a 2xx), and the two we saw in this lab work like this.
status_code: a 2xx response counts as claimed.message: a body without the “not found” text counts as claimed.
Both tests fail open. A WAF page that returns 200 passes the first test, and a block page that lacks the “not found” sentence passes the second, so every hit is a lead for you to check, never a finding. That is the whole reason this guide spends as much time on verification as on installation.
Point the tool only at usernames you have a legitimate reason to look up: your own handles, accounts inside an authorised engagement, or a test handle like the cfgprobe2026 used here. Checking whether a name exists uses public pages, but building a profile of a private person from the results can break privacy law and platform terms where you live.
pipx installs the current release
The project README lists pipx install sherlock-project as the first install method. It was also the only route in this test that delivered the latest release on both Ubuntu versions. pipx gives Sherlock its own virtual environment, so its pandas and openpyxl dependencies never touch your system Python. On Kali or Ubuntu, install pipx from the distro first:
sudo apt update
sudo apt install -y pipx
Then add the pipx bin directory to your PATH and install the package. The PyPI package is called sherlock-project, while the command it installs is plain sherlock:
pipx ensurepath
pipx install sherlock-project
pipx reports the Python it built the environment with. That was Python 3.14.4 on Ubuntu 26.04 and 3.12.3 on 24.04, and the package metadata accepts anything from 3.9 up to, but not including, 4.0:

Read the yellow warning before you type sherlock. ensurepath edits your shell’s startup file (~/.bashrc on Ubuntu, ~/.zshrc on Kali, whose default shell is zsh), but the shell you’re in still has the old PATH, so in the same session the command fails with sherlock: command not found. Any one of these fixes it.
- open a new terminal
- log out and back in
- run
source ~/.bashrc(orsource ~/.zshrcon Kali)
After that, the version check and the install path should both line up. If which prints a path outside ~/.local/bin, an older distro package is shadowing the pipx copy:
sherlock --version
which sherlock
The screenshot also shows what apt would have given you on the same Ubuntu 26.04 machine. That candidate line is the reason pipx is the default in this guide:

The gap is not cosmetic. Default output, the exclusion list and the Tor flags all changed across those releases, so the same command behaves differently depending on where your copy of Sherlock came from. A tutorial written against one build can produce an error, a missing file or a different hit count on another, and that’s the first thing to rule out when your results don’t match someone else’s. Run sherlock --version before you compare anything.
Distro packages lag behind PyPI
Every packaged build we checked was older than the one pipx installed. In order from newest to oldest, this is what each source offered during the test:
- PyPI through pipx: the current release
- Kali main and the Docker image: the previous release
- Ubuntu 26.04 universe: one minor release older
- Ubuntu 24.04 universe: a January 2024 git snapshot
On a fresh Kali install, covered in our post-install checklist for Kali Linux, the package is one apt install away, whether Kali runs on a laptop or as a VM in a Proxmox pentest lab. Check the candidate before you commit to it:
apt-cache policy sherlock
sudo apt install -y sherlock
Inside the kali-rolling container, the candidate came from the main Kali repository and ran on the system Python. The policy output below was captured before the install, which is why it still reads Installed: (none).
sherlock:
Installed: (none)
Candidate: 0.16.0-3
Version table:
0.16.0-3 500
500 http://http.kali.org/kali kali-rolling/main amd64 Packages
Ubuntu is further behind. On 24.04 the same query returned a snapshot that predates both the exclusion list and the Tor deprecation:
sherlock:
Installed: (none)
Candidate: 0.14.3+git20240119.e3a09f8-1
The upstream Sherlock README goes further. It warns that the third-party packages for ParrotOS and Ubuntu 24.04 “appear to be broken” and tells users of those systems to use pipx, pip or Docker instead. We didn’t install the 24.04 package to confirm that, since pipx already gave the newer release on the same machine. On Kali the package is a reasonable choice if you accept the previous release. It’s the same upstream 0.16.0 release as the Docker image below, which wrote a txt file without being asked in our test; we only ran --version from the Kali package itself.
The Docker image runs a release behind
The sherlock/sherlock image is handy on a host where you don’t want Python packages at all, and the README lists docker run -it --rm sherlock/sherlock as its second install method. Our lab host got Docker from Ubuntu’s own docker.io package (sudo apt install -y docker.io), and any recent Docker Engine works the same. The image entrypoint is the sherlock command itself, so your arguments go straight after the image name:
sudo docker run --rm sherlock/sherlock --version
sudo docker run --rm sherlock/sherlock cfgprobe2026 --site GitHub --site Reddit
The latest tag reported an older release than pipx, and some runs printed an update notice pointing at 0.16.2. Notice the Reddit hit for a handle we made up, because it comes back in the false-positive section:

Exports are the catch. With --rm, any file Sherlock writes inside the container disappears with it, and the run prints exactly the same results either way, so nothing tells you the CSV is gone until you go looking for it. Mount a host directory and make it the working directory, because Sherlock writes its files into whatever directory it starts in.
mkdir -p ~/dock && cd ~/dock
sudo docker run --rm -v "$PWD":/opt/sherlock -w /opt/sherlock sherlock/sherlock blue --site GitHub --csv --no-color
ls -l
Both files landed on the host. The image also wrote blue.txt without being asked, which the pipx release no longer does:
total 8
-rw-r--r-- 1 root root 164 Nov 11 17:40 blue.csv
-rw-r--r-- 1 root root 68 Nov 11 17:40 blue.txt
Both files are owned by root because the container runs as root. You can still delete them, since the directory is yours, but a later pipx run that writes blue.csv into the same directory can’t overwrite them without sudo. Running the container as your own user with --user "$(id -u):$(id -g)" should avoid that, though we didn’t test that variant.
A first search hits every site
With no options, Sherlock checks the full default list, prints only the hits, and saves nothing. Two searches show what that looks like: a common word that’s taken almost everywhere, and the test handle that shouldn’t exist anywhere.
time sherlock blue --no-color
time sherlock cfgprobe2026 --no-color
blue came back with 202 results in a little over two minutes. The made-up handle took just as long and still produced six hits:

So why does a handle we made up take two minutes and find six accounts? The output answers both halves:
- user time was about 12 seconds, so most of the wall time is spent waiting out the 60-second default timeout on slow sites
- we made the handle up and never registered it, so the six hits are probable false positives; curl confirmed only YouTube as absent (404), and the rest are unproven either way
- later runs added Twitch, while Reddit only showed up when the Docker run named it with
--site
Treat a single run as a sample, not a census. Sites rate-limit, time out and change their pages between one run and the next, so the hit list you get is one snapshot of how those servers answered your address at that moment. If a hit matters, you need it in more than one run before it goes anywhere near a report. Every 0.16.2 run also ends with a two-line promotion for a commercial service, OSINTSearch. It is not an error, and no flag in the help output turns it off.
Nothing is saved until you ask
Older guides tell you Sherlock writes a username.txt after every search. Sherlock 0.16.0 still did, and its release notes added a --no-txt opt-out. By 0.16.2 the default is reversed: no file is written unless you pass a format flag, --txt is the opt-in, and --no-txt fails with “unrecognized arguments”. These are the flags that write output, as tested:
| Flag | What it wrote in the lab |
|---|---|
--txt | blue.txt in the current directory: one URL per line plus a total |
--csv | blue.csv in the current directory, with HTTP status and response time per site |
--xlsx | blue.xlsx (Excel 2007+ format) |
-o FILE alone | Nothing at all |
-o FILE --txt | The txt report at FILE |
-o FILE --csv | blue.csv in the current directory; the -o path was ignored |
-fo DIR alone | Nothing at all |
-fo DIR --txt --csv | One txt and one csv per username inside DIR |
The two traps are -o and -fo. Both only choose where a file goes, so on their own they produce nothing and print no warning. For several usernames, the combination that worked is a folder plus explicit formats:
sherlock --folderoutput ~/runs/fo blue cfgprobe2026 --txt --csv --site GitHub --site Reddit --site GitLab
ls -la ~/runs/fo
Each username gets its own pair of files. Look at the HTTP status column in the CSV for the made-up handle.

That row says Claimed with a 403, which is the CSV handing you the false positive in plain sight. Sorting a CSV on http_status is the fastest triage you can do. In the full blue export, three of the 198 claimed rows carried a 403.
–print-all changes the CSV too
We exported blue three times with --csv: plain, with --print-found, and with --print-all. The first two matched apart from run-to-run noise, because printing found sites is already the default. --print-all added every negative result to the screen and to the file. Counting rows and the values of the exists column in each file with a few lines of Python gave this summary:
csv_default.csv 198 {'Claimed': 198}
csv_found.csv 199 {'Claimed': 199}
csv_all.csv 420 {'WAF': 21, 'Available': 185, 'Claimed': 198, 'Unknown': 14, 'Illegal': 2}
The exists column is where --print-all earns its place. Beyond Claimed, it uses four values:
Available: the site answered and the name is freeWAF: a bot-detection page answered insteadUnknown: connection errors and timeoutsIllegal: the name does not fit that site’s format
Those 35 WAF and Unknown rows are sites that never answered the question. A default export drops them silently, so you can’t tell “not registered” from “never checked” without --print-all, and they’re exactly the sites a proxy can change. For any search you plan to repeat, export with --print-all once so you know which part of the list your network can’t reach.
–json loads data, it doesn’t export it
Some guides list --json as “save results in JSON”. The help text says otherwise: --json, -j JSON_FILE loads a site manifest from a file, a URL or an upstream PR number. Pass it a file that doesn’t exist and you get a load error, not an export.
ERROR: Problem while attempting to access data file '/nonexistent.json'.
Pointing it at the raw data.json URL in the GitHub repository worked, and so did --local, which forces the manifest bundled with the package. The confusion is understandable, because most CLIs use --json for output, but here a wrong value changes which sites get checked, so a typo can quietly change the scope of your search. For machine-readable results, use --csv.
Limit the sites and the wait
You rarely need all 400 sites, and three flags decide how much of the list you hit and how long you wait:
--site NAME, repeated once per site--timeout SECONDS, 60 by default--nsfw, which adds the adult sites the default list skips
A short site list with a 10-second timeout is the fastest useful run. Here it is against three developer sites:
time sherlock blue --site GitHub --site GitLab --site Reddit --timeout 10 --no-color
All three came back in about a second:
[*] Checking username blue on:
[+] GitHub: https://www.github.com/blue
[+] GitLab: https://gitlab.com/blue
[+] Reddit: https://www.reddit.com/user/blue
[*] Search completed with 3 results
real 0m1.083s
On the full list, dropping the timeout from 60 seconds to 30 cut the blue run from about two minutes to about 65 seconds, and both runs reported 202 results. --nsfw grew the --print-all output for the test handle from 427 lines to 443, so it checks 16 more sites.
Tor is now just a SOCKS proxy
Many tutorials still show sherlock user --tor. The Sherlock releases page records the change, and the current help confirms it:
- 0.15.0 deprecated
--torand--unique-tor - the current help lists neither flag
- both now fail with
unrecognized arguments
The replacement is the generic --proxy flag pointed at a local Tor daemon. Install Tor, enable it so it survives a reboot (Kali doesn’t start network services by default), and check the daemon unit, tor@default. On Debian-family systems the plain tor unit is a wrapper around it, so its status says less about the daemon itself (our lab checked the plain unit, which printed active, and the circuit test below is the real proof):
sudo apt install -y tor
sudo systemctl enable --now tor
systemctl is-active tor@default
Tor listens for SOCKS clients on 127.0.0.1:9050 by default. Use the socks5h:// scheme so DNS lookups go through Tor as well, and confirm the circuit before you trust it. Tor needs a moment after start to build its first circuit (we allowed about 20 seconds), so retry the check if the first curl comes back empty. PySocks is already a Sherlock dependency, so the proxy needs no extra package:
curl -s --socks5-hostname 127.0.0.1:9050 https://check.torproject.org/api/ip
time sherlock blue --no-color --timeout 30 > direct.out
time sherlock blue --no-color --timeout 30 --proxy socks5h://127.0.0.1:9050 > tor.out
grep -h "Search completed" direct.out tor.out
Run back to back on the same machine, the Tor run took about a third longer and returned fewer hits:

Does Tor just hide you, then? No, it changes the answers. An earlier pair of runs showed the same pattern, 202 direct against 174 over Tor in 97 seconds. That earlier diff wasn’t one-sided either: the Tor run lost Chess, Carrd and BuyMeACoffee but gained 7Cups and Aparat, so each route sees sites the other one misses. Use Tor when the lookup must not come from your address, and compare against a direct run before you read anything into the counts.
Most false positives are blocks
The Reddit hit for cfgprobe2026 showed up in the Docker run and in every --site Reddit run, so it’s worth taking apart. --dump-response prints the URL Sherlock built, the test it applied, the status code and the full response body. Filtering that down to the useful lines tells the story:
sherlock cfgprobe2026 --site Reddit --dump-response --no-color | grep -oE "TARGET.*|TEST METHOD.*|RESPONSE CODE.*|ERROR TEXT.*|VERDICT.*|blocked by network security\."
Reddit answered with a 403 and a page saying the request was blocked by network security. The message test looked for “Sorry, nobody on Reddit goes by that name.”, didn’t find it on the block page, and called the account claimed.

That’s a common shape of a Sherlock false positive. The site refused to answer, and the test read the refusal as a yes. Comparing Sherlock’s verdicts with plain curl from the same machine gave a mixed picture, and only one site came back as clearly absent.
- Reddit: a 403 block page passed the message test
- YouTube: Sherlock saw 200, curl got 404
- Houzz and Tweakers: Sherlock saw 200, curl got a 301 that we did not follow, so it proves nothing on its own
- Twitch: curl got a 200 as well, so a status check can’t settle it either way
Only Reddit’s case is clearly a block page; the others may come down to the site entry itself, since Sherlock sends a HEAD request and follows redirects where curl here sent a GET and did not. The Reddit page only says the request was “blocked by network security”, which suggests the site refused a cloud address, so the same manifest entry can behave differently on a VPS than on a home connection. We only tested from cloud machines, so treat that as the first thing to rule out rather than a rule. You might expect --verbose to explain more, but it only prints the response time next to each hit. --dump-response is the flag that shows you why a verdict happened.
The exclusion list hides the worst sites
Since 0.16.0, Sherlock skips sites that upstream testing flagged as prone to false positives. Reddit behaves as if it is on that list: it never appeared in a default full run, yet it appeared whenever we named it with --site or turned exclusions off. --ignore-exclusions brings the whole list back, and comparing both runs on a handle we never registered shows what the filter is worth:
sherlock cfgprobe2026 --no-color --timeout 20 | grep "^\[+\]" | sort > default.txt
sherlock cfgprobe2026 --no-color --timeout 20 --ignore-exclusions | grep "^\[+\]" | sort > ignored.txt
wc -l default.txt ignored.txt
comm -13 default.txt ignored.txt | head -8
Six hits became 48. Every extra line is a site Sherlock marks as claimed for a handle we never registered, including DeviantArt, Archive.org and both Apple forums:

Leave the exclusions on unless you are debugging one specific site. When you do turn them off, run the same flags against a nonsense handle first, because whatever that control run reports is your noise floor from that network.
Errors you will actually hit
These came up during the lab runs, in roughly the order a new user meets them. Each one has a one-line fix once you know what Sherlock is actually complaining about.
bash: sherlock: command not found
pipx installed the command into ~/.local/bin, but your current shell doesn’t have that directory on its PATH yet. Run pipx ensurepath once, then open a new terminal or source your shell’s rc file (~/.bashrc on Ubuntu, ~/.zshrc on Kali). Scripts that run over a non-login SSH session need the full path, ~/.local/bin/sherlock, or their own PATH export.
sherlock: error: unrecognized arguments: –tor
The Tor flags were deprecated in 0.15.0 and are not in the current release. Run a Tor daemon and pass --proxy socks5h://127.0.0.1:9050 instead. --unique-tor has the same fix, and the same error for --no-txt means you can simply drop the flag, because no txt file is written by default.
ERROR: Problem while attempting to access data file
You passed --json expecting an export. The flag loads a site manifest, so Sherlock tried to open your filename as input and exited with status 1. Replace it with --csv or --xlsx and the run goes through.
BrokenPipeError: [Errno 32] Broken pipe
Piping Sherlock into head closes the pipe early. The final promotional line then fails to write, which dumps a colorama traceback after the results. Your results are fine, and piping into grep or redirecting to a file avoids it, since both read the whole stream.
Blocked by bot detection (proxy may help)
This line appears only with --print-all. In the blue run it was the second most common negative after “Not Found!”, with 21 sites, ahead of 12 connection errors and one timeout. Those sites gave no answer at all from a cloud address, so either retry them through a proxy or check them by hand.
Prove a hit from outside Sherlock
Before a username search result goes into a report, confirm it with something that does not share Sherlock’s test. A raw request is the cheapest second opinion, and following redirects with a browser user agent mirrors what a person would see:
curl -s -o /dev/null -w "%{http_code}\n" https://www.youtube.com/@cfgprobe2026
curl -s -o /dev/null -w "%{http_code} %{url_effective}\n" -L -A "Mozilla/5.0" https://www.reddit.com/user/cfgprobe2026
Neither “found” profile held up from the same machine. YouTube returned 404, and Reddit returned the same 403 that Sherlock had counted as a hit:
404
403 https://www.reddit.com/user/cfgprobe2026
A 404 kills the lead outright. A 403 means the site would not say, so open the URL in a normal browser from a residential connection, or look for content only the real account would have. In order, these are the checks that held up in this lab:
- Run a nonsense handle with the same flags and drop any site it also “finds”.
- Export with
--csvand distrust everyClaimedrow without a 200. - Read the remaining hits with
--dump-responsefor a block page. - Confirm survivors with
curlor a browser, and record what you saw.
Sherlock is a fast way to decide where to look, not proof that anything is there. If you’re building out the rest of a recon toolkit on the same machine, our guide to network scanning with Nmap on Kali covers the next layer down. Hydra password testing shows where authorised credential checks fit, and the Kali Linux books list goes deeper on methodology.