DEV Community

Deek Roumy
Deek Roumy

Posted on

How to Use Opire to Find Unclaimed GitHub Bounties (With Real Data From 30 Live Bounties)

#api #github #opensource #tutorial

Most developers have never heard of Opire. Fewer still know it has a fully public API that returns every active bounty in real-time — no authentication needed.

I spent a day building an automated scanner using that API. Here's what I found in 30 live bounties, how the claim mechanism works, and which ones are still up for grabs.

What Is Opire?

Opire is a platform that lets anyone — maintainers, sponsors, even random users — add cash bounties to GitHub issues. Unlike Algora or IssueHunt, Opire uses a comment-based flow directly on GitHub. You don't need a separate dashboard to participate.

The full flow:

  1. A sponsor drops @opire-dev create $50 as a comment on any GitHub issue
  2. Opire's bot registers the reward
  3. Developers post /try to declare intent
  4. After a merged PR: post /claim #<issue-number> in the PR body
  5. Payment goes out via Stripe

What makes it special: it's decentralized. Anyone can fund any issue. The bounty lives on GitHub, not behind a walled garden.

The Secret Weapon: Opire's Public API

Here's the thing nobody talks about: Opire exposes all active rewards at one endpoint with zero authentication:

curl -s "https://api.opire.dev/rewards"
Enter fullscreen mode Exit fullscreen mode

That's it. A single GET request returns a JSON array of every active bounty on the platform. I wrote a script to pull this, cross-reference each issue against the GitHub Issues API, and rank them by value × competition × feasibility.

Here's a minimal version of that scanner:

const fetch = require('node-fetch');

async function scanOpireBounties() {
  // Step 1: Fetch all rewards from Opire API
  const res = await fetch('https://api.opire.dev/rewards');
  const rewards = await res.json();

  console.log(`Total bounties: ${rewards.length}`);

  // Step 2: For each reward, check the GitHub issue status
  for (const reward of rewards) {
    const { issue_url, amount, currency } = reward;

    // Parse owner/repo/issue_number from GitHub URL
    const match = issue_url.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
    if (!match) continue;

    const [, owner, repo, issue_number] = match;

    // Check if issue is still open
    const ghRes = await fetch(
      `https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}`,
      { headers: { 'User-Agent': 'bounty-scanner' } }
    );
    const issue = await ghRes.json();

    if (issue.state === 'open') {
      console.log(`✅ $${amount} | ${owner}/${repo} | ${issue.title}`);
    } else {
      console.log(`❌ CLOSED | $${amount} | ${owner}/${repo}`);
    }
  }
}

scanOpireBounties();
Enter fullscreen mode Exit fullscreen mode

Running this on March 22, 2026, I found 30 total bounties — but 8 of them were on closed issues. That means 27% of the money listed on Opire is effectively stranded on work that's already done. Knowing this is itself an edge.

Real Data: What 30 Live Bounties Look Like

Here's the breakdown of the open bounties I found, ranked by value:

Amount Language Repo Claimers Competition
$13,380 C++ godotengine/godot 3 HIGH
$1,500 C uswriting/zeroperl 0 ⭐ NONE
$1,000 C FalkorDB/FalkorDB 3 HIGH
$660 JavaScript hexgrad/kokoro 2 LOW-MEDIUM
$385 Rust zed-industries/zed 1 MEDIUM
$200 C++/C/GLSL secondlife/viewer 1 LOW
$180 Python autokey/autokey 4 MEDIUM-HIGH
$120 TypeScript typeorm/typeorm 7 HIGH
$100 C FalkorDB/FalkorDB 1 LOW
$70 Rust denoland/deno 0 ⭐ ZERO
$70 TypeScript trovu/trovu 7 VERY HIGH
$50 PHP sebastianbergmann/phpunit 2 LOW

Key finding: The $70 Deno bounty (feat: view test coverage in editor, issue #18147) had zero claimers on the day I scanned it. It was also last updated that same day — a fresh, active issue with no one competing for it.

The /try Mechanism: How Claiming Works

When you find a bounty you want to attempt, the process on GitHub is:

# Step 1: Comment on the issue to declare intent
/try

# Step 2: Fork the repo, implement your fix

# Step 3: Open a PR and include this in the PR body
/claim #<issue-number>

# Step 4: Maintainer merges → Opire pays out
Enter fullscreen mode Exit fullscreen mode

The /try comment is purely for signaling — it doesn't lock you out if others also comment it. But it tells the sponsor you're working on it, which sometimes prompts them to respond with guidance.

Important: Multiple developers can post /try and even open PRs. The maintainer picks which PR to merge. This is different from first-come-first-served platforms — quality of implementation wins, not speed.

What Closed Bounties Teach You

Out of 30 bounties in my scan, these 8 were on closed GitHub issues:

  • $385 — zed-industries/zed Helix keymap (closed 2026-03-09)
  • $200 — Leantime collaborators on task (closed 2025-11-15)
  • $200 — keycloak IDP token refresh (closed 2026-01-02)
  • $110 — storybookjs select control bug (closed 2026-01-18)

Opire doesn't auto-expire rewards when issues close. The money may be in limbo unless the sponsor explicitly cancels it. Always verify issue status on GitHub before investing time.

# Quick check: is this issue still open?
curl -s "https://api.github.com/repos/OWNER/REPO/issues/NUMBER" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['state'], d['title'])"
Enter fullscreen mode Exit fullscreen mode

Tips for Actually Winning Bounties

After analyzing all 30 bounties, here's what I learned:

1. Target issues with open PRs that have CHANGES_REQUESTED

The $120 TypeORM bounty has 4 open PRs — but none merged. Why? The maintainer wants a fix across ALL database drivers, not just one. Reading PR review comments reveals exactly what "done" looks like.

2. Low dollar ≠ low value

The $50 phpunit bounty (improve error message for empty coverage list) is probably a 2-hour fix in a well-documented PHP codebase. That's $25/hour for clean, beginner-friendly work.

3. Zero claimers is your biggest signal

When the competition count is 0, the bounty is essentially unclaimed territory. The Deno $70 and zeroperl $1,500 had zero claimers. The zeroperl one requires deep C systems work, but the Deno one is "just" an LSP integration.

4. Check language feasibility honestly

$13,380 on Godot sounds incredible until you realize it's a complex C++ rendering issue. Match the bounty to your actual skillset.

5. Comment /try early, even before you start

It signals intent, sometimes prompts the maintainer to add context, and establishes your claim date. Takes 5 seconds.

The Full Scanner

I've published the full bounty scanner — with GitHub cross-referencing, competition scoring, and Markdown report generation — on GitHub at @DeekRoumy.

If you want to see how I built the AI agent that runs this automatically (and wakes up to scan for bounties while I sleep), check out my first article: How I Built an AI Agent That Hunts GitHub Bounties While I Sleep.

Summary

  • Opire's public API: https://api.opire.dev/rewards — no auth needed
  • 30 live bounties totaling ~$18,000 on the day I scanned
  • 8 were on closed issues (27% stranded money)
  • The $70 Deno bounty had zero claimers
  • Claim flow: /try on issue → PR → /claim #N in PR body → maintainer merges → payout
  • Best strategy: find bounties where existing PRs have CHANGES_REQUESTED and understand why they were rejected

The platform is small enough that reading the GitHub discussions gives you a real edge. Most people won't do that homework. You just did.

Happy hunting. 🎯

Top comments (0)