# Algora Bounty Radar (`sebarb/algora-bounty-radar`) Actor

Read-only scout for public Algora/GitHub bounty candidates with safety, funding, and competition filters.

- **URL**: https://apify.com/sebarb/algora-bounty-radar.md
- **Developed by:** [Seba](https://apify.com/sebarb) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scored bounty candidates

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Algora Bounty Radar

Find public open-source bounty leads worth reviewing before you spend implementation time.

Algora Bounty Radar is a read-only Apify Actor that searches public GitHub and Algora-style bounty signals, then scores each candidate for funding evidence, payout-route confidence, competition, safety risk, and implementation clarity.

The Actor is built for operators, contributors, and agencies that want a smaller, safer review queue instead of a long list of bounty-looking issues.

### What It Does

- Searches public GitHub issue data with bounty-focused queries.
- Detects public Algora-style funding signals and explicit USD/USDC amounts.
- Scores candidates by funding proof, payout route, acceptance criteria, freshness, competition, and safety.
- Separates results into `REVIEW`, `MONITOR`, and `REJECT`.
- Writes normalized rows to the default Apify dataset.
- Writes a compact run summary to the default key-value store output.

### What It Does Not Do

- It does not claim bounties.
- It does not submit pull requests.
- It does not comment on GitHub issues.
- It does not guarantee payment, acceptance, or bounty wins.
- It does not configure wallets, Stripe, tax, or payout accounts.
- It does not use private repos, private mailbox data, cookies, or session data.

### Best Use Cases

- Building a shortlist of funded OSS issues for manual review.
- Filtering noisy GitHub reward text before assigning engineering time.
- Monitoring whether public bounty leads have enough evidence to justify deeper review.
- Auditing why a high-dollar issue is still too risky or too vague to pursue.

### Input

The main inputs are:

- `queries`: GitHub search queries. Keep these narrow and bounty-specific.
- `rails`: preferred evidence rails, such as `algora` and `github_text_seed`.
- `minAmountUsd`: minimum clear bounty amount.
- `maxOpenPrs`: maximum visible open pull requests before a candidate is rejected.
- `maxClaimCount`: maximum claim-like comment count before a candidate is rejected.
- `maxResults`: maximum rows to return.
- `rejectUnsafePatterns`: rejects prompt disclosure, fake engagement, social gates, wallet-funding traps, and unsafe production testing.
- `dryRun`: uses provided seed issues or bundled examples and skips live GitHub search.
- `seedIssues`: optional issue records for controlled testing.

Example:

```json
{
  "queries": [
    "algora bounty is:issue is:open",
    "\"$\" \"bounty\" is:issue is:open"
  ],
  "minAmountUsd": 25,
  "maxOpenPrs": 2,
  "maxClaimCount": 2,
  "maxResults": 25,
  "rejectUnsafePatterns": true,
  "dryRun": false
}
```

### Output

Each dataset row represents one scored candidate.

Important fields:

- `decision`: `REVIEW`, `MONITOR`, or `REJECT`.
- `score`: numeric confidence score.
- `rail`: detected evidence rail.
- `funding_proof`: funding evidence class, such as `public_bounty_page` or `text_only`.
- `payout_route`: expected payout route when it can be inferred from public evidence.
- `amount` and `currency`: detected bounty amount.
- `repo`, `issue_number`, `title`, `issue_url`, and `bounty_url`.
- `risk_flags`: unsafe or low-trust patterns found in the issue text.
- `reject_reasons`: concrete reasons the candidate should not receive implementation time.
- `next_action`: manual next step recommendation.

Example row:

```json
{
  "decision": "REVIEW",
  "score": 84,
  "rail": "algora",
  "funding_proof": "public_bounty_page",
  "payout_route": "stripe_connect",
  "amount": 2500,
  "currency": "USD",
  "repo": "algora-io/algora",
  "issue_number": 238,
  "title": "[UI Bug] Unauthorized 'Edit' and 'Delete' buttons visible on /bounties page",
  "issue_url": "https://github.com/algora-io/algora/issues/238",
  "risk_flags": [],
  "reject_reasons": [],
  "next_action": "Manual review before any patch-prep packet. This Actor does not claim, comment, or create PRs."
}
```

### Decision Labels

`REVIEW` means the candidate has enough public signal for manual due diligence. It is not a patch instruction.

`MONITOR` means the candidate has some useful signal but needs better funding, acceptance, or competition evidence.

`REJECT` means the Actor found a concrete reason to avoid spending implementation time.

### Data Sources

This Actor uses public GitHub issue search data and public issue text. It may infer Algora-style evidence from public references to Algora, bounty pages, or bounty amounts. Inferred payout routes are directional signals, not payout guarantees.

### Operational Notes

Use `dryRun: true` for private tests and controlled demos. Use low `maxResults` values for first live runs. Review `REVIEW` rows manually before starting any implementation work.

For public Store use, pricing charges for filtering and scoring value, not for bounty outcomes. The intended pay-per-event event is `scored-candidate`, charged once per scored dataset row when the Actor is configured as a paid Apify Actor.

# Actor input Schema

## `queries` (type: `array`):

Search queries used only for read-only discovery. Keep them narrow and bounty-specific.

## `rails` (type: `array`):

Preferred evidence rails. Text-only GitHub matches are scored conservatively.

## `minAmountUsd` (type: `integer`):

Ignore candidates with lower clear USD-equivalent amounts.

## `maxOpenPrs` (type: `integer`):

Reject candidates with too much visible implementation competition.

## `maxClaimCount` (type: `integer`):

Reject candidates where many comments indicate claims or attempts.

## `maxResults` (type: `integer`):

Maximum scored candidates to output.

## `rejectUnsafePatterns` (type: `boolean`):

Reject prompt disclosure, star gates, fake engagement, vague rewards, stale issues, and closed work.

## `dryRun` (type: `boolean`):

When enabled, score only seedIssues or bundled examples and skip live GitHub search. The Actor is read-only regardless of this setting.

## `seedIssues` (type: `array`):

Optional local issue records to score before or instead of live search. Useful for private dry runs and local tests.

## Actor input object example

```json
{
  "queries": [
    "algora bounty is:issue is:open",
    "\"$\" \"bounty\" is:issue is:open"
  ],
  "rails": [
    "algora",
    "github_text_seed"
  ],
  "minAmountUsd": 25,
  "maxOpenPrs": 2,
  "maxClaimCount": 2,
  "maxResults": 25,
  "rejectUnsafePatterns": true,
  "dryRun": false,
  "seedIssues": []
}
```

# Actor output Schema

## `bountyCandidates` (type: `string`):

Scored bounty candidate rows written to the default dataset. The overview view highlights decision, score, funding evidence, payout route, amount, issue URL, risk flags, rejection reasons, and next action.

# 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("sebarb/algora-bounty-radar").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("sebarb/algora-bounty-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 sebarb/algora-bounty-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sebarb/algora-bounty-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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