Teaching Claude Everything You've Hacked

Dear Readers,

h1-brain is an MCP server that syncs your HackerOne bounty history into a local SQLite database and makes it available to Claude. It also ships with a database of publicly disclosed bounty-awarded reports from the HackerOne community. You type hack(handle) and it cross-references your personal history and public disclosures against the target’s scope: what you’ve been ignoring, what other researchers found, which weakness types have paid off, and where to focus next.

graph LR
    A["Claude Desktop / Code"] -->|MCP Protocol| B["h1-brain server"]
    B -->|API calls| C["HackerOne API"]
    B -->|reads / writes| D["Your Reports DB"]
    B -->|reads| E["Public Reports DB"]
    C -->|reports, programs, scopes| B
    D -->|your history + analysis| A
    E -->|community knowledge| A
    style A fill:#ff5c5c,stroke:#ff5c5c,color:#fff
    style B fill:#1a1d27,stroke:#ff5c5c,color:#fff
    style C fill:#1a1d27,stroke:#555,color:#fff
    style D fill:#1a1d27,stroke:#555,color:#fff
    style E fill:#1a1d27,stroke:#555,color:#fff

What MCP is, in 30 seconds

#

MCP stands for Model Context Protocol. It’s an open standard that lets AI assistants like Claude talk to external tools. Instead of copy-pasting data into a chat window, you run an MCP server that exposes tools and data directly to the model. Claude can call those tools, get structured results back, and reason over them.

Other HackerOne MCP tools

#

h1-brain isn’t the only HackerOne MCP server out there, and it’s worth knowing what else exists so you pick the right one for what you’re trying to do:

• HackerOne’s official GraphQL MCP server — Built by HackerOne themselves. It’s a thin Docker wrapper around their GraphQL API via Apollo MCP Server, which means you get raw access to everything on the platform but without any bounty-specific logic on top of it.

• Sicks3c’s hackerone-mcp-server — A Node.js server with 9 tools including report search, conversation threads, earning tracking, and analyze_report_patterns for submission trends.

• blackknight75’s hackerone_mcp_server — More focused on the program management side with duplicate detection, scope validation, weekly reporting, and MDC compliance rules from a YAML config. Six tools, mostly aimed at managing incoming reports.

h1-brain does something different. It syncs your entire bounty history into a local database and then cross-references it: your weakness patterns, which scope you’ve never touched, what worked on other programs that you haven’t tried here. The other tools give you API access. h1-brain gives you a starting point for your next session.

Prerequisites

#

• Python 3.10 or newer
• A HackerOne account with submitted reports (the more the better)
• A HackerOne API token
• Claude Desktop or Claude Code

Getting your API token

#

Go to hackerone.com/settings/api_token and generate a token. You’ll get an API identifier and an API token. The identifier is your username for the API, the token is your password. Keep both, you’ll need them in a minute.

Installation

#

git clone https://github.com/PatrikFehrenbach/h1-brain.git
cd h1-brain
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

The server creates a SQLite database (h1_data.db) for your personal data the first time you run it. The public disclosed reports database (disclosed_reports.db) is included in the repo — no extra setup needed.

Wiring it into Claude

#

Claude Desktop

#

Open your config at ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) and add:

{
  "mcpServers": {
    "h1-brain": {
      "command": "/path/to/h1-brain/venv/bin/python",
      "args": ["/path/to/h1-brain/server.py"],
      "env": {
        "H1_USERNAME": "your_hackerone_username",
        "H1_API_TOKEN": "your_api_token"
      }
    }
  }
}

Replace the paths and credentials, restart Claude Desktop, and you should see h1-brain in the tools list when you click the hammer icon.

One thing worth mentioning if you’re on Claude Desktop: use Opus for h1-brain work. Sonnet is faster but it tends to skim over the hack() briefing and miss the suggested vectors section entirely. Opus actually reads the whole thing and connects the dots between your history and the target, and for a tool that’s all about cross-referencing patterns, reasoning quality matters more than speed.

Claude Code

#

claude mcp add h1-brain \
  -e H1_USERNAME=your_hackerone_username \
  -e H1_API_TOKEN=your_api_token \
  -- /path/to/h1-brain/venv/bin/python /path/to/h1-brain/server.py

With Claude Code you can have Claude pull your hack() briefing, then read your local notes or recon output, and reason over both at once. If you’re using extended thinking, Claude will deliberate on the relationship between your past findings and the current scope before answering. Turn it on for anything that involves analysis.

Another thing worth knowing: if you put a CLAUDE.md file in your project directory, you can pre-load instructions like “always start with hack() when I give you a program handle” or “when I say ‘sync’, run fetch_rewarded_reports and fetch_programs.” Claude reads that file at the start of every session, so you don’t have to repeat yourself every time you open a new conversation.

Populating your database

#

The first time you connect, your database is empty. Ask Claude:

“Sync my HackerOne data. Run fetch_rewarded_reports and fetch_programs”

Claude will call both tools and you’ll see something like:

Fetched and stored 147 rewarded reports (out of 312 total). Total bounties: $87,350.00

Fetched and stored 64 programs.

That first number is important because h1-brain only stores rewarded reports, filtering out informative, duplicate, and N/A closures. What you get in the database is your confirmed track record, the stuff that actually paid. The HackerOne API paginates at 100 items per page and h1-brain handles that automatically, fetching report details concurrently 10 at a time. If you hit a rate limit (HTTP 429), it backs off for 60 seconds and retries on its own.

Once that’s done, you don’t need to run these again unless you want to pick up new reports. The data lives locally in h1_data.db and all the search and analysis tools read from that database without making any API calls, so everything after the initial sync is fast and works offline.

After syncing, it’s worth running get_report_summary() to sanity-check what actually landed. Ask Claude:

“Give me a summary of my report history”

You’ll get back something like:

Total: 147 reports, $87,350 earned

- **shopify**: 23 reports, $18,700
- **github**: 12 reports, $14,200
- **uber**: 8 reports, $11,500
- **yahoo**: 15 reports, $8,900
...

If programs are missing or the numbers look wrong, resync.

What gets stored

#

erDiagram
    reports ||--o{ attachments : "has"
    reports {
        text id PK
        text title
        text program_handle
        text weakness_name
        text severity_rating
        real bounty_amount
        text vulnerability_information
    }
    programs {
        text id PK
        text handle
        text name
        int offers_bounties
    }
    scopes {
        text id PK
        text program_handle
        text asset_identifier
        text asset_type
        int eligible_for_bounty
        text max_severity
    }
    attachments {
        text id PK
        text report_id FK
        text file_name
        text content_type
        int file_size
    }

h1-brain uses two databases:

h1_data.db — your personal data, four tables:

• reports — ID, title, state, program handle, weakness name and CWE, severity rating and score, bounty amount and currency, the full vulnerability write-up, and disclosure date.
• programs — ID, handle, name, submission state, whether it offers bounties, currency.
• scopes — Program handle, asset identifier, asset type, whether it’s eligible for bounties, whether it accepts submissions, max severity, and any special instructions.
• attachments — ID, report ID, file name, content type, file size, creation date.

disclosed_reports.db — publicly disclosed reports from the HackerOne community that paid a bounty and have actual vulnerability write-ups (redacted/empty reports are excluded). Each report includes title, vulnerability details, weakness type, program, asset, CVEs, and bounty amount. Ships with the repo, queried by search_disclosed_reports(), get_disclosed_report(), and hack().

What’s next

#

In the next post I’ll walk through every tool h1-brain exposes — including the new disclosed reports tools — what they do, when you’d use them, and what the output looks like.

Until next time 🙂