# Verified Open-Source Bounty Feed (`lebeepboop/github-bounty-sniper`) Actor

Automatically scans GitHub for fresh, low-competition software engineering bounties with escrow verification and anti-honeypot filtering.

- **URL**: https://apify.com/lebeepboop/github-bounty-sniper.md
- **Developed by:** [Tham Zhi Cheng](https://apify.com/lebeepboop) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 🎯 GitHub Bounty Sniper

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?logo=apify)](https://apify.com)
[![GitHub](https://img.shields.io/badge/GitHub-API%20v3-181717?logo=github)](https://docs.github.com/en/rest)
[![Escrow Verified](https://img.shields.io/badge/Escrow-Algora%20%7C%20Opire%20%7C%20Polar-success)](#)

Find verified, high-paying, and low-competition open-source bounties on GitHub. **GitHub Bounty Sniper** searches active issues backed by verified escrow platforms (like Algora.io, Opire.dev, and Polar) while filtering out bot spam, scraper mirrors, and malicious prompt-injection honeypots.

***

### ⚡ Why Use GitHub Bounty Sniper?

Finding bounties manually is tedious:

- Most bounty tags are outdated or already solved.
- Many issues are flooded with dozens of competing developers.
- Some repos are automated mirror spam or honeypot traps aimed at AI coding agents.

**GitHub Bounty Sniper automates the hunt** so you can be the first to grab high-yield, verified issues:

- 💎 **Verified Escrow Backing**: Targets bounties backed by reputable escrow platforms (**Algora**, **Opire**, **Polar**, and 💎 diamond tags) with real financial commitments.
- 🛡️ **Anti-Honeypot & Bot Defense**: Actively scans and eliminates AI agent traps, prompt injection payloads, and mirror scraper clones (e.g. `bounty-watcher`, `bounty-plaza`).
- 🏎️ **Low Competition (First-Mover Filter)**: Filters issues by maximum human comment count so you discover bounties before the crowd arrives.
- 🌐 **Language & Freshness Targeting**: Focus on your strongest stacks (`TypeScript`, `Python`, `Rust`, `Go`, `JavaScript`, etc.) within your preferred timeframe.
- ⚖️ **Repo Diversity Safeguard**: Automatically caps results per repository so no single project dominates your dataset.
- 💵 **Automatic Reward Extraction**: Intelligently extracts and normalizes reward values in USD (e.g. `$50`, `$250`, `$1.5k`).

***

### 📥 Input Configuration

Configure your search criteria in the Actor input:

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `languages` | `Array<String>` | `["TypeScript", "JavaScript", "Python"]` | Target programming languages to search. |
| `minBountyUsd` | `Integer` | `50` | Minimum payout threshold in USD. |
| `maxComments` | `Integer` | `3` | Maximum human comments allowed (filters out crowded bounties). |
| `maxAgeDays` | `Integer` | `90` | Maximum age of issues in days (skips stale/abandoned repos). |
| `maxItems` | `Integer` | `25` | Maximum number of verified bounties to return. |
| `excludeHoneypots` | `Boolean` | `true` | Enables strict checks against prompt-injection traps and bot honeypots. |
| `githubToken` | `String` | `""` *(Optional)* | GitHub Personal Access Token (PAT) to boost API rate limits. |

#### Sample Input

```json
{
  "languages": ["TypeScript", "Python", "Rust"],
  "minBountyUsd": 50,
  "maxComments": 3,
  "maxAgeDays": 60,
  "maxItems": 20,
  "excludeHoneypots": true,
  "githubToken": ""
}
```

***

### 📤 Output Data Format

Every discovered bounty is saved to the dataset as an individual record with normalized properties:

| Field | Type | Description |
| :--- | :--- | :--- |
| `title` | `String` | GitHub issue title |
| `estimatedRewardUsd` | `Number` | Estimated or guaranteed payout amount in USD |
| `language` | `String` | Primary programming language |
| `repository` | `String` | Repository in `owner/repo` format |
| `issueNumber` | `Integer` | Issue number |
| `issueUrl` | `String` | Direct web link to the GitHub issue |
| `humanCommentsCount` | `Integer` | Number of comments excluding initial bot comments |
| `totalCommentsCount` | `Integer` | Total comment count |
| `author` | `String` | Username of the issue author |
| `createdAt` | `String` | ISO timestamp of issue creation |
| `escrowVerified` | `Boolean` | `true` if verified escrow backing is detected |
| `labels` | `Array<String>` | Issue labels |
| `bodyPreview` | `String` | Sanitized description snippet (first 300 characters) |

#### Sample Output Record

```json
{
  "title": "Fix memory leak in background worker queue",
  "estimatedRewardUsd": 150,
  "language": "TypeScript",
  "humanCommentsCount": 1,
  "totalCommentsCount": 2,
  "repository": "acme-corp/fast-queue",
  "issueNumber": 342,
  "issueUrl": "https://github.com/acme-corp/fast-queue/issues/342",
  "author": "octocat",
  "createdAt": "2026-10-12T15:30:00Z",
  "escrowVerified": true,
  "labels": ["bounty", "bug", "💎 $150"],
  "bodyPreview": "We have an open bounty via Algora.io ($150) for fixing the memory consumption spike occurring when processing batched jobs..."
}
```

***

### 🔑 GitHub API Rate Limits

- **Unauthenticated**: GitHub allows up to 10 search requests per minute. The Actor includes automatic pacing to stay within limits.
- **With Personal Access Token (PAT)**: Adding a GitHub fine-grained or classic token (with read-only public access) increases your quota to **30 search requests per minute and 5,000 core requests per hour**, allowing faster multi-language sweeps.

***

### 🚀 How to Run

#### Via Apify Console

1. Open [GitHub Bounty Sniper on Apify](https://console.apify.com).
2. Configure your languages, minimum reward amount, and maximum comment threshold.
3. Click **Start** to run.
4. View the results directly in the **Overview table** or export to **JSON, CSV, or Excel**.

#### Via Apify CLI

```bash
apify run
```

#### Deploy Local Changes

```bash
apify push --force
```

***

### 💡 Pro Tips for Bounty Hunters

1. **Keep `maxComments` low (1–3)**: Bounties with 0–1 comments represent the highest success rate. Once an issue has 5+ comments, a PR is usually already in progress.
2. **Automate via Schedules**: Set this Actor on an Apify schedule (e.g. every 2–4 hours) to receive immediate webhook or Slack notifications when fresh bounties appear.
3. **Check `escrowVerified`**: Prioritize issues where `escrowVerified` is `true` to ensure the bounty funds are deposited with Algora or Opire.

# Actor input Schema

## `languages` (type: `array`):

Filter repositories by primary language (e.g., TypeScript, JavaScript, Python, PHP, Java).

## `maxComments` (type: `integer`):

Only return bounties with less than or equal to this many comments so you don't compete with crowds.

## `minBountyUsd` (type: `integer`):

Only return bounties paying at least this amount in USD.

## `maxItems` (type: `integer`):

Maximum number of verified bounties to scrape in this run.

## `excludeHoneypots` (type: `boolean`):

Requires verified escrow bot confirmation (algora-pbc / opire) and blocks prompt-injection traps.

## `githubToken` (type: `string`):

Optional GitHub read-only token to increase API rate limits.

## `maxAgeDays` (type: `integer`):

Only return bounties created within the last X days to avoid abandoned repos.

## Actor input object example

```json
{
  "languages": [
    "TypeScript",
    "JavaScript",
    "Python"
  ],
  "maxComments": 3,
  "minBountyUsd": 50,
  "maxItems": 25,
  "excludeHoneypots": true,
  "maxAgeDays": 90
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lebeepboop/github-bounty-sniper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("lebeepboop/github-bounty-sniper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call lebeepboop/github-bounty-sniper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lebeepboop/github-bounty-sniper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jR9WbyxpXv6ktIPMT/builds/hjfccYWsacnYqp8bf/openapi.json