deanonymizer: measuring what a public posting history gives away

One username, four platforms, and a pile of crumbs

The GitHub description of deanonymizer reads "Deanonymize anyone based on their public commenting or posting history & pattern". The README narrows that within its first screen: run it on yourself, or on someone who asked you to, see the exposed parts, and fix them before someone less friendly runs the same exercise. That gap between tagline and usage note is the first thing to understand about this tool, because the machinery inside it does not care which side of the request it serves.

The premise it builds on is that individually harmless signals add up. A timezone mentioned in passing. A remark about a former employer. The same handle on four different sites. The README credits one paper for the inference setting, arXiv:2602.16800, and compresses its premise into a single line: a disclosure that looks non-identifying on its own can become identifying once you fuse it across posts and platforms. Low entropy alone, high entropy together.

So the tool is for people who want to measure their own pile of crumbs before an observer does it for them. It is a TypeScript CLI, it works from public APIs, and it keeps insisting it is not an identity oracle. That insistence is a feature, and the limitations framing shows up again in the report format.

Where the evidence comes from

Collection covers four sources plus an opportunistic fifth. Reddit posts and comments come from the Arctic Shift API. Hacker News items come from the HN Algolia Search API. GitHub contributes profile fields and public events (commits, issues, pull requests, review comments) through the GitHub REST API, and commit author name and email tucked inside PushEvent payloads get folded in inline, which the README calls a juicy source. A GITHUB_TOKEN dropped in the environment raises the rate limit. Stack Overflow hands over answers, questions, comments and profile fields via the Stack Exchange API v2.3.

The fifth source is the interesting one. If a GitHub or Stack Overflow profile links out to a personal website, a shallow link-follower reads it: the root page, then up to five same-origin sub-pages, prioritizing paths that look identity-shaped, such as /about, /cv, /resume, /contact, /bio, /me and /portfolio. It preserves mailto: and http(s):// href values before stripping the HTML, so a contact email hiding behind a link survives the pass. People put their address in an anchor tag constantly, and that is exactly what this step is for.

Every source returns its own record shape, so everything maps into one unified item schema with normalized timestamps and text. The later inference works from bounded, consistent context instead of five different JSON dialects.

An LLM pass and a regex pass, running side by side

Feature extraction is two passes in parallel, and their division of labor is the core design decision. The LLM pass reads the corpus for the soft stuff: location, affiliations, daily-routine timing, self-disclosed demographics, cross-platform handles, external URLs and stylometric tells. Every claim it makes gets bound to evidence, meaning a quote and a permalink. If it says you live somewhere, it has to show where you said it.

The deterministic regex pass ignores the model entirely and goes after hard, unambiguous leaks. It catches emails, including the [at] and [dot] obfuscations people use, which it unmangles. It also catches cross-platform social handles for LinkedIn, Twitter/X, GitHub, YouTube, Instagram, Bluesky, Reddit, Hacker News, Telegram, GitLab, Stack Overflow and Mastodon, pulled out of URL patterns in the text. It filters false positives like twitter.com/home, and it excludes the account you are auditing so it does not discover the handle you just typed in.

The architecture point is that hard facts do not depend on the model behaving. One dependency is worth flagging: package.json lists @anthropic-ai/sdk and openai, so the soft pass calls a hosted model, and the README does not document how that provider key is configured. The only environment variable it names is GITHUB_TOKEN.

What a finished report contains

Findings get confidence-calibrated into low, medium and high, and the human-readable report groups them high to medium to low with reasoning attached. There is an explicit "this is the exact user" section plus the set of public proof URLs behind it. A dedicated direct-identifier block, the emails and cross-platform handles the regex pass caught, renders before the LLM findings on purpose: concrete leaks show up front no matter how the model phrased its summary.

Each finding carries its own remediation suggestion, so the report reads as bad news plus what to do about it rather than a wall of alarms. JSON output exists for tracking over time or feeding another system, with AuditResult.directIdentifiers exposing the raw email and social handle hits alongside the model's findings.

There is also an optional strict mode, and its behaviour is a sensible guard: the run fails if there is no external proof URL beyond the audited platform's own profile pages. In other words, a report that only proves things the profile already states publicly is treated as a failure, not a result.

Install and a first audit

It is a Node project, and the README's installation section gives exactly one command:

npm install

After that, the runnable entries live in package.json. Its scripts block names the relevant ones:

  "scripts": {
    "build": "tsc",
    "audit": "tsx src/index.ts",
    "start": "tsx src/index.ts",

So an audit runs as npm run audit or npm start, both of which invoke tsx against src/index.ts without a separate compile, and a build step runs tsc for the dist output that the bin entry (an executable named audit pointing at ./dist/index.js) expects. What you should see at the end of a run is the ranked report with the direct-identifier block in front. For any GitHub-heavy subject, expect rate limits unless a GITHUB_TOKEN is set, which the README documents as raising the limit.

Limits, licence, and a manual alternative

The threat model is narrow on purpose, and the README states it as a boundary: a passive adversary who can read public text and metadata, nothing more. No private APIs, no logging in, no credentialed access, no secret datasets, no scraping behind a paywall. Anything you never posted publicly is out of scope for this tool and for the attacker it models. That is also its honest limit: it measures what you leaked, not what a subpoena or a breach would find.

There is a privacy wrinkle in running it on yourself. The soft pass ships your fused corpus to whichever hosted model those two SDKs call, so the audit is itself a small disclosure decision. Auditing a friend with their consent sends their corpus too.

The licence situation needs one paragraph. The repository tree contains no LICENSE file at all, GitHub reports no licence, yet package.json declares MIT. Anyone redistributing relies on a one-line declaration rather than licence text, which is a gap worth closing before you depend on the tool.

The manual alternative costs nothing and stays local: search each handle on each platform, read profile fields and the personal sites they link to, and list every employer mention and timezone slip yourself. You lose the confidence calibration, the stylometric pass and the permalink-bound claims, and you lose the LLM in the loop. For one handle, manual is workable. For tracking exposure over time across four platforms plus a website, the report format is the actual product here. The last push was on 2026-06-15.

Editorial conclusion

deanonymizer fits people who maintain public identities across Reddit, Hacker News, GitHub or Stack Overflow and want a ranked, evidence-bound view of what those identities combine to reveal, provided they accept that the soft inference pass calls a hosted model with that corpus. It does not fit anyone who needs an offline tool, or who requires a licence file before depending on something. Verify first: the provider key setup the README does not document, how strict mode behaves on handles whose evidence never leaves the audited platform, and the missing LICENSE file against the MIT declaration in package.json. The last push was on 2026-06-15.

Frequently asked questions

Official sources

1. Issues
2. ni5arga/deanonymizer on GitHub
3. README