# GitHub Paid Issues & Bounty Finder (`coolinbex/github-paid-issues-bounty-finder`) Actor

Find open GitHub issues offering bounties, cash rewards, or paid developer work. Filter noisy results by reward, language, repository stars, freshness, and confidence.

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

## Pricing

from $8.00 / 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 Paid Issues & Bounty Finder

Find open GitHub issues that offer **bounties, cash rewards, or paid developer work** and return them as clean, structured Apify dataset rows.

This Actor is designed for developers, bounty hunters, research workflows, and coding agents that need better signals than a raw GitHub keyword search.

### What it does

- Searches open public GitHub issues through the official GitHub REST API
- Detects bounty, reward, paid-task, prize, and compensation signals
- Extracts reward amounts from formats such as `$500`, `500 USD`, `300 USDT`, `EUR 250`, `0.5 ETH`, and `2k USD`
- Removes weak keyword matches and optional aggregator/feed-style issues
- Deduplicates issues found by multiple search terms
- Detects assigned or possibly claimed work
- Enriches results with repository stars, primary language, archive state, fork state, and license
- Filters by reward, currency, language, stars, repository, organization, freshness, and confidence
- Sorts by actionability, reward, freshness, creation date, or comments
- Provides complete Apify input, output, and dataset schemas

### Recommended Store metadata

**Title:** `GitHub Paid Issues & Bounty Finder`

**Description:** `Find open GitHub issues offering bounties, cash rewards, or paid developer work. Filter noisy results by reward, language, repository stars, freshness, and confidence.`

### Quick start

The defaults work without configuration:

```json
{}
```

A targeted run:

```json
{
  "languages": ["TypeScript", "Python"],
  "minimumRewardAmount": 100,
  "rewardCurrency": "USD",
  "minimumStars": 20,
  "updatedWithinDays": 90,
  "maxResults": 50
}
```

Search specific repositories:

```json
{
  "repositories": ["owner/project", "another/repo"],
  "minimumConfidence": "high",
  "maxResults": 25
}
```

### Output

Each dataset row includes:

- issue title, number, URL, repository, and repository URL
- bounty/reward type
- minimum and maximum detected reward
- currency and whether the currency was explicit
- short reward evidence text
- detection confidence and confidence score
- actionability score
- matched signals and labels
- author, assignees, claim status, comments
- created/updated timestamps
- repository stars, primary language, license, archive/fork state
- optional issue body preview

#### Example

```json
{
  "issueTitle": "Bounty: implement retry handling — $250 USD",
  "issueUrl": "https://github.com/example/project/issues/42",
  "repository": "example/project",
  "issueNumber": 42,
  "bountyType": "bounty",
  "rewardAmountMin": 250,
  "rewardAmountMax": 250,
  "rewardCurrency": "USD",
  "confidence": "high",
  "actionabilityScore": 94,
  "primaryLanguage": "TypeScript",
  "repositoryStars": 1200,
  "claimStatus": "unassigned"
}
```

### Detection quality

The Actor uses conservative heuristics rather than returning every issue containing the word `bounty`.

A result becomes stronger when it has combinations of:

- bounty/reward/paid wording in the title
- bounty/reward/paid labels
- explicit payment phrases such as `will pay` or `paid on merge`
- a monetary amount close to a payment signal
- a currently open issue with recent activity

Generic planning discussions that merely mention bounties are rejected. Feed/index issues containing many bounty links can also be excluded.

`confidence` and `actionabilityScore` are discovery heuristics. They **do not guarantee that the maintainer will pay**. Always open the source issue and verify eligibility, requirements, claim status, and payment terms before doing work.

### GitHub token

A token is optional for small runs. Add one for larger searches or many repository lookups.

The Actor only needs public read access. The `githubToken` input is marked as a secret in the Apify input schema and is never logged by the Actor.

GitHub applies separate and more restrictive limits to search endpoints, so authenticated runs are more reliable at higher volume.

### Pricing on Apify

The simplest Pay Per Event setup is to price the synthetic event:

`apify-default-dataset-item`

Each qualified result is pushed once to the default dataset, so users are charged only for results you actually return. You do **not** need a custom event in the code.

For example, a price of `$0.008` on `apify-default-dataset-item` means 100 returned results cost `$0.80` in result-event charges, before any platform-specific rules or discounts.

### Local development

```bash
npm install
npm test
npm run check
npm start
```

Local Actor input can be placed in the standard Apify local storage input file.

### Deploy

```bash
apify login
apify push
```

Then run the Actor once with default input and inspect the dataset before publishing it to the Store.

### Limits

- GitHub search exposes at most 1,000 results per individual search query.
- Very large runs can hit GitHub API rate limits; use a token.
- Dollar symbols without an explicit code are treated as USD for practical discovery, while `rewardCurrencyExplicit` remains `false`.
- The Actor does not claim issues, contact maintainers, submit code, or guarantee payouts.

# Changelog

This Actor's version history is a separate document: https://apify.com/coolinbex/github-paid-issues-bounty-finder/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Terms used to discover candidate issues. Each term is searched as literal text, then results are verified by the Actor.

## `repositories` (type: `array`):

Optional owner/repo list. Leave empty to search public GitHub globally.

## `organizations` (type: `array`):

Optional GitHub organization names. Leave empty for no organization restriction.

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

Optional primary-language filter, for example JavaScript, TypeScript, Python, Go, Rust. Repository metadata lookup is enabled when this is used.

## `minimumRewardAmount` (type: `integer`):

Minimum numeric reward. For meaningful comparisons across results, also choose a reward currency.

## `rewardCurrency` (type: `string`):

Only return issues whose detected primary reward uses this currency. ANY accepts all supported currencies.

## `includeWithoutExplicitAmount` (type: `boolean`):

Keep strong bounty/paid-work matches even when no amount can be parsed.

## `minimumConfidence` (type: `string`):

Confidence describes how strongly the issue text looks like a paid task. It does not guarantee payment.

## `minimumStars` (type: `integer`):

Optional repository popularity filter. Set 0 to disable.

## `updatedWithinDays` (type: `integer`):

Only keep issues updated within this many days. Set 0 for any age.

## `excludeAggregators` (type: `boolean`):

Remove issues that mainly list or mirror many other bounties instead of offering one concrete task.

## `excludeArchivedRepositories` (type: `boolean`):

Remove results from archived repositories after repository metadata is checked.

## `sortBy` (type: `string`):

How accepted results are ordered before writing them to the dataset.

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

Maximum qualified issues written to the default dataset. A GitHub token is recommended above 40 results.

## `includeBodyPreview` (type: `boolean`):

Include a short plain-text preview of the issue body in each result.

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

Optional GitHub personal access token for higher API limits. Public read access is sufficient. The value is stored encrypted by Apify.

## `debug` (type: `boolean`):

Log extra diagnostics. The GitHub token is never logged.

## Actor input object example

```json
{
  "searchTerms": [
    "bounty",
    "cash reward",
    "paid task",
    "paid issue",
    "reward"
  ],
  "repositories": [],
  "organizations": [],
  "languages": [],
  "minimumRewardAmount": 0,
  "rewardCurrency": "ANY",
  "includeWithoutExplicitAmount": true,
  "minimumConfidence": "medium",
  "minimumStars": 0,
  "updatedWithinDays": 0,
  "excludeAggregators": true,
  "excludeArchivedRepositories": true,
  "sortBy": "actionability",
  "maxResults": 25,
  "includeBodyPreview": true,
  "debug": false
}
```

# Actor output Schema

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

No description

## `summary` (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("coolinbex/github-paid-issues-bounty-finder").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("coolinbex/github-paid-issues-bounty-finder").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 coolinbex/github-paid-issues-bounty-finder --silent --output-dataset

```

## MCP server setup

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

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/Qyri5jFpvY9tlAX8q/builds/Zgdff7UhB5Qp03Ib5/openapi.json