TargetFinder
Collects public Bugcrowd engagements and their scope (via bounty-targets-data or the engagement changelog), detecting VDPs from the reward summary.
Sends alerts to a Discord webhook after each sync about new programs, watchlist changes and fresh in-scope targets, without repeating previously sent notifications.
Tracks in-scope source repositories: watches tracked HEADs, detects new pushes, fetches compare links and diffs (classified as code/docs/deps/ci/tests), and can optionally use a GITHUB_TOKEN for a higher compare rate budget.
Collects the scope of public HackerOne programs via its public directory GraphQL API (programs, structured scopes, public stats), including reports submitted in the last 90 days, paid reports and first-response times used to score targets.
Collects public Intigriti programs through its public programs API, with scope information for programs that expose a public scope.
Sends the same sync alerts (new programs and scope, watchlist changes, new in-scope targets) to a Telegram chat via bot token and chat id.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@TargetFinder find me hot bug bounty programs that are free to submit to"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
TargetFinder
Find bug-bounty targets worth your time, from public data, on your own machine. TargetFinder collects the scope of every public program on HackerOne, Bugcrowd, Intigriti, YesWeHack, HackenProof and Sherlock, tracks what changed since the last run (new programs, new targets, removed targets, fee and reward changes, pushes to in-scope source repositories) and serves it through a CLI, a local HTTP API and an MCP server for AI assistants.
What it looks like
targetfinder leads hot --free: programs worth a look right now, free to submit to.

targetfinder program gitlab: one program as a card, with its best-scored targets.

targetfinder status: collector health, so you know the data is fresh.

Related MCP server: platform-adapter-mcp
Who this is for
People hunting their first bounty. The hard part early on is not finding bugs, it is picking a target that is fresh, in scope, pays, and is not already crowded. TargetFinder puts that information in one place and tells you when it changes. If you would rather not run anything, the hourly data published by the GitHub Action (see below) is the same thing as JSON files.
Always confirm scope on the program page before testing. Platforms change scope, rules and rewards without notice; the program page is the only source that counts when you submit.
Quickstart
git clone https://github.com/NaroChatyan/targetfinder.git && cd targetfinder
bin/targetfinder init # first run: collects every platform (10–20 min), writes public/ snapshots
bin/targetfinder sweep # the report: new programs, fee changes, added/removed targets, pushes, rankingsKeep it fresh, pick one:
bin/targetfinder sweep --sync # on demand: collect, then report
bin/targetfinder schedule install --every 1 # hourly in the background (systemd user timer on Linux, launchd on macOS; prints the schtasks command on Windows)
bin/targetfinder loop --every 2 # foreground loop: sync + sweep every 2 hours, Ctrl-C to stopOr as a container, with the data kept in a named volume:
docker build -t targetfinder .
docker run -v targetfinder-data:/data targetfinder init
docker run -v targetfinder-data:/data targetfinder sweep
docker run -i -v targetfinder-data:/data targetfinder # the MCP server over stdioReports land in sweeps/SWEEP_<date>.md with a JSON twin. The first run records a baseline, so the
first sweep shows no "added" targets: changes are only reported for things TargetFinder had already seen.
What you get
command | what it does |
| the standing report; a paid submission fee is the only thing that gets deprioritised, nothing is hidden |
| browse programs and their scope with scores |
| target changes, page or cursor mode |
| pushes to in-scope repositories with compare links, classified code / docs / deps / ci / tests |
`targetfinder leads top | hot |
`targetfinder rankings scope | rewards |
| your watchlist; the sweep and the alerts give it its own section |
| which of your local git clones are behind the tracked HEAD, with the pushes you missed |
| saves the compare diff of a push to |
| which program lists an asset |
| HTTP API on |
| MCP server over stdio (18 tools, docs/API.md) |
| counts, collectors, last successful run per platform, stale flags |
| find a program id from a name; payout signals and platform-published facts |
Every lookup prints a readable table; add --json for the same data as JSON. targetfinder alone prints
the grouped command list, targetfinder <command> -h the options. Exit codes: 0 ok, 1 not found, 2 usage
error, 3 every collector failed. Colors appear only on a terminal and honour NO_COLOR.
Alerts (Discord / Telegram)
bin/targetfinder notify setup --discord <webhook-url> --telegram-token <bot-token> --telegram-chat <chat-id>
bin/targetfinder notify testAfter every sync you get: brand-new programs with their scope, watchlist changes (targets, fee, rewards,
status, code pushes) and fresh in-scope targets everywhere (free-submission only by default; tune with
notify setup --min-score 50 --platforms HackerOne,YesWeHack --free-only off). Nothing is sent twice; the
first sync after setup only initialises the cursors. Credentials live in data/notify.json (mode 600) or
in DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID.
MCP (Claude Code, Cursor, any MCP client)
{"mcpServers": {"targetfinder": {"command": "/path/to/targetfinder/bin/targetfinder", "args": ["mcp"]}}}Start with the guide tool. recent_target_changes and recent_repo_pushes take an after_id cursor
for polling; find_programs and leads accept free_submission_only.
Use the published data without running anything
The repository's GitHub Action runs sync every hour and commits JSON snapshots to the data branch:
programs.json, targets.json (active and inactive rows with added_at / removed_at), repos.json
(tracked HEADs), and 90-day windows of target_changes_90d.json, program_events_90d.json,
repo_changes_90d.json, payouts_90d.json, plus meta.json. Fetch them raw, or clone and run
bin/targetfinder import-snapshot --in public to get a local database with history, then sync to
continue from there. The data branch always holds exactly one commit (each run rewrites it, so the
repository does not grow by 55 MB an hour); the 90-day history is inside the files. GitHub pauses scheduled
workflows after 60 days without commits, which the hourly data commits prevent.
Data sources
platform | what is read | notes |
HackerOne | public directory GraphQL (programs, structured scopes, public stats) | reports/90d, paid/90d, first-response hours feed the briefs |
Bugcrowd |
| VDPs detected from the reward summary |
Intigriti | public programs API; scope from bounty-targets-data | only public-scope programs have targets |
YesWeHack | public API: programs and program detail | submission cost in credits is the fee |
HackenProof | listing and program pages | submission fee and reward table from the program page |
Sherlock | bug-bounties listing and detail pages | the per-report USDC deposit is recorded as the fee |
Immunefi | off by default (its terms prohibit automated access, docs/PLATFORMS.md) |
|
Request rates are conservative (one request in flight per host, at least one second apart, 1.5 s on
HackerOne) with an identifying User-Agent. Every collector has fixture tests; a platform that changes
its pages makes its collector fail loudly, keeps the previous data intact, and is flagged stale in
status and at the top of the sweep.
Scores are heuristics
competitionRisk and opportunity scores are comparative estimates derived from public counts, not measured probabilities. Target scores (0–100, labels top/strong/promising/normal), competition levels (low/medium/high/unknown) and lead tiers (top/hot/solid/possible) are TargetFinder's own point models over freshness, target type, maximum bounty and public report counts; docs/SCORING.md lists every weight. Report counts mean different things on different platforms, so use scores to order a list, never to skip reading the program page.
Layout
targetfinder/ package: collectors/, sync, repowatch, snapshot, queries, model, activity, api, mcp_server, sweep, tools, notify, schedule, cli
bin/targetfinder launcher
tests/ unittest suite (python3 -m unittest -v); tests/fixtures/ holds recorded, trimmed platform payloads
tools/record_fixtures.py maintainer tool: re-record the fixtures (network)
docs/ API.md, DESIGN.md, SCORING.md, PLATFORMS.md
public/ JSON snapshots (written by init / export-snapshot, git-ignored on main; the data branch in CI)
data/ your database and logs (git-ignored)Environment: TARGETFINDER_DATA_DIR, TARGETFINDER_DB, TARGETFINDER_SWEEP_DIR, TARGETFINDER_API_HOST,
TARGETFINDER_API_PORT, TARGETFINDER_ENABLE_IMMUNEFI, GITHUB_TOKEN (optional: raises the GitHub compare
budget used to classify pushes from 50/h to 5000/h).
Contributing
Run python3 -m unittest -v (no network). To add a platform, write parse_listing / parse_scope as pure
functions, record a trimmed fixture with tools/record_fixtures.py, add the terms review line to
docs/PLATFORMS.md, and register collect(). MIT licensed.
Support
TargetFinder is free and has no paid tier. If it helped you land a bounty and you want to give something back, small amounts on cheap networks are welcome:
network | address |
ETH or USDC on Base, Arbitrum or Ethereum |
|
USDT (TRC-20) on TRON |
|
Send on the network named next to the address; funds sent on another network cannot be recovered. HAPPY HACKING!!!
Available Tools
18 toolsexport_targetsC
Bounded export (max 500 rows) of current targets.
Inputs: tags, limit, tiers, platforms, +3 more.
find_program_by_targetC
Which program(s) list a domain / URL / repo / wildcard.
Inputs: target (required), platforms.
find_programsC
Program discovery with combined filters.
Inputs: full, kind, sort, tags, +8 more.
get_programB
One program by id, handle or unambiguous name (full object).
Inputs: program_id (required).
guideA
How to choose among these tools; id format; filter vocabulary.
Inputs: no named parameters.
leadsD
Programs in one lead tier.
Inputs: tier (required), page, tags, search, +3 more.
list_filtersC
Observed filter values (platforms, tags, target types) and the fixed vocabularies.
Inputs: no named parameters.
list_targetsC
Targets of one program with scores.
Inputs: program_id (required), type, label, limit, +6 more.
program_briefB
One-screen summary: rewards, fee, competition, scope counts, recent activity, payouts, sample eligible targets.
Inputs: program_id (required).
program_historyB
Event history (program/scope/rewards/fees/status/repositories) for one program, or all programs when program_id is omitted.
Inputs: limit, since, cursor, category, +1 more.
program_payoutsC
Payout facts, windows, signals and labels for one program.
Inputs: program_id (required).
rankingsD
One ranked page of a view.
Inputs: view (required), sort, tags, kinds, +6 more.
recent_repo_pushesC
Source-repository pushes (page mode or after_id cursor). Compare links, no code.
Inputs: page, tags, kinds, since, +7 more.
recent_target_changesD
Target changes (page mode or after_id cursor).
Inputs: page, tags, type, since, +12 more.
run_sweepB
Run the standing sweep report and return the markdown.
Inputs: since, write.
search_targetsC
Search targets across all programs.
Inputs: q, page, tags, page_size, +4 more.
statusB
Database counts, last sync, collectors and their last successful run.
Inputs: no named parameters.
watchlist_new_targetsC
New in-scope targets for a list of programs since a timestamp.
Inputs: program_ids (required), since.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Most tools target distinct resources and actions: program lookup, target listing/search, repository pushes, filters, and exports are clearly separated. Some overlap remains between find_programs and leads, between program_brief and program_payouts, and between recent_target_changes and watchlist_new_targets, but the guide tool and descriptions help disambiguate.
All names use snake_case, but conventions are mixed: verb-led names (find_programs, get_program, list_targets, search_targets) coexist with noun-led or bare-noun names (guide, status, leads, rankings, program_brief, program_history). The names remain readable, but there is no single predictable verb_noun pattern.
Eighteen tools is somewhat heavy for a program/target discovery server, with several meta or shortcut tools (guide, status, list_filters, leads) that could potentially be folded into others. It is not excessive for the domain's breadth, but it sits above the ideal 3–15 range.
The surface covers discovery, detailed program summaries, target listing/search, history, change feeds, rankings, filters, exports, and sweeps, so core read-only workflows are well supported. Minor gaps exist around watchlist management (only watchlist_new_targets is present, with no list/add/remove operations) and direct target-detail lookup.
Maintenance
Related MCP Connectors
Search and monitor bug bounty programs and audit contests across ten platforms.
34 security tools for AI agents: phishing links, exposure maps, DNS, SSL, PQC, history, pivots.
Real-time CVE, exploit, and vulnerability intelligence for AI assistants (350K+ CVEs, 115K+ PoCs)
AI pentesting: run scans, triage vulnerabilities, review PRs, manage schedules and assets.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides Claude Code with access to a comprehensive bug bounty knowledge base including techniques, payloads, wordlists, and real-world reports through 14 tools for searching, retrieving payloads, and assessing report quality.1421GPL 3.0
- FlicenseNot gradedqualityDmaintenanceWraps multiple bug bounty platform APIs (HackerOne, Bugcrowd, etc.) behind a uniform MCP tool surface, enabling LLM agents to query programs, scope, and briefs across platforms through a single interface.-
- AlicenseAqualityBmaintenanceEnables AI assistants and agents to search bug bounty programs, retrieve policies and scopes, and check targets against active scope across HackerOne, YesWeHack, and Intigriti using personal API credentials.5MIT
- AlicenseAqualityCmaintenanceEnables AI agents to query bug-bounty programs, scopes, rules, payouts, reports, statistics, and researcher rankings through the platform's public API, with optional private-program access via a session cookie.101MIT