# GitHub Issue and PR Alert Monitor by Keyword (`scrapemint/github-issue-monitor`) Actor

Track GitHub issues and pull requests by keyword, repo, label, state, and star floor. Uses the official GitHub REST API v3. Deduped across runs. Built for devtool founders, DevRel, open source maintainers, and PMs who need a live feed of category mentions, bug reports, and competitor issue activity.

- **URL**: https://apify.com/scrapemint/github-issue-monitor.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 21 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 github issue matches

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 Issue and PR Alert Monitor by Keyword

Pull GitHub for new issues and pull requests that match your keywords, repos, labels, state, and star floor. Export title, body, author, labels, reactions, repo metadata, and timestamps to JSON, CSV, or Excel. Deduped across runs. Uses the official GitHub REST API. Pay per item.

**Searches this actor is built for:** GitHub intelligence, pull GitHub issues, GitHub issue tracker, GitHub PR monitor, GitHub API alternative, GitHub keyword alert, track GitHub issues, competitor GitHub monitor, GitHub lead generation.

***

### How it works in 30 seconds

```mermaid
flowchart LR
    A[Your keywords<br/>or repo list] --> B[GitHub REST API]
    B --> C[Filter: keyword,<br/>state, label, stars, age]
    C --> D[Deduped JSON feed<br/>of new items only]
    D --> E[Webhook to Slack,<br/>CRM, Notion]
```

Paste a keyword or a `owner/repo` slug. Pick filters. Get a clean JSON feed of new GitHub issues and pull requests every run. That is the whole product.

***

### Who this GitHub scraper is for

| You are a... | You use this to... |
|---|---|
| **Devtool founder** | Catch every issue in your category mentioning your library or a competitor. Turn it into warm outbound. |
| **DevRel engineer** | Build a live queue of mentions ready for a helpful reply or bug fix. |
| **Open source maintainer** | Watch downstream repos for bug reports filed against a library you publish. |
| **Product manager** | Mine real user language from issue bodies to inform your next sprint. |
| **Competitive intel** | Track every issue filed in a competitor's repo, spot pain before their changelog does. |

***

### How to pull GitHub issues step by step

```mermaid
flowchart TD
    A[1. Pick queries or repos] --> B[2. GitHub REST API v3]
    B --> C[3. Paginate 100 per page]
    C --> D[4. Filter by keyword,<br/>state, label, stars, age]
    D --> E[5. Push to Apify dataset]
    E --> F[6. Store ID in<br/>SEEN_IDS key value store]
    F -.->|Next run| G[7. Skip seen IDs]
```

1. Pass search queries, `owner/repo` slugs, or both.
2. The actor calls the official GitHub REST API v3: `/search/issues` for keyword search, `/repos/{owner}/{repo}/issues` for direct repo watching.
3. Results pass through keyword, state, label, star, and age filters.
4. Matches land in your Apify dataset.
5. Item IDs go into a named key value store so future runs skip duplicates.

Schedule every 10 minutes on Apify Scheduler and you get a live stream of new issues. Add a free personal access token and your rate limit jumps from 60 to 5000 core requests per hour.

***

### Quick start

**Monitor mentions of your library across all of GitHub:**

```json
{
  "searchQueries": ["\"langchain\" in:title,body"],
  "itemType": "issues",
  "state": "open",
  "maxAgeHours": 168,
  "githubToken": "YOUR_GITHUB_TOKEN"
}
```

**Watch 3 competitor repos for new bugs:**

```json
{
  "repos": ["pinecone-io/pinecone-python-client", "weaviate/weaviate", "qdrant/qdrant"],
  "keywords": ["slow", "timeout", "crash"],
  "state": "open",
  "labels": ["bug"]
}
```

**Lead gen on Postgres pain, high signal repos only:**

```json
{
  "searchQueries": ["postgres slow query in:title,body"],
  "minRepoStars": 100,
  "state": "open",
  "maxAgeHours": 72
}
```

Or run it from the command line:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~github-issue-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["langchain vector"],"state":"open","maxAgeHours":168}'
```

***

### GitHub scraper vs the alternatives

```mermaid
flowchart LR
    M[Manual repo checking] --> X[Browse each repo,<br/>miss the first wave]
    S[GitHub alert SaaS] --> Y[$20 to $99 per month,<br/>email only]
    A[This Apify actor] --> Z[Pay per item,<br/>raw JSON, your webhook]
```

| Feature | Manual | Alert SaaS | This actor |
|---|---|---|---|
| Pricing | Free, costs time | $20 to $99 per month | Pay per item, first 2 free |
| Keyword cap | Unlimited if you click | 5 to 50 per tier | Unlimited |
| Repo targeting | Tab hopping | Fixed repo list | Any repo or global search |
| Label filter | Click on GitHub | Premium tier | Built in |
| Reactions data | Hover on GitHub | Not included | Full count per emoji |
| Scheduling | You | Hourly | Every 1 minute |
| Dedup across runs | Your memory | Vendor owned | Yours, in key value store |
| Output | Browser tab | Email | JSON, CSV, Excel, webhook |

***

### Sample output

One issue record:

```json
{
  "issueId": "2387491023",
  "number": 1842,
  "itemType": "issue",
  "title": "Vector search returns empty result for multi lingual input",
  "body": "I'm trying to build a RAG pipeline with LangChain and Pinecone...",
  "state": "open",
  "url": "https://github.com/langchain-ai/langchain/issues/1842",
  "repo": {
    "slug": "langchain-ai/langchain",
    "owner": "langchain-ai",
    "name": "langchain",
    "stars": 98421,
    "language": "Python"
  },
  "author": {
    "login": "devfounder99",
    "url": "https://github.com/devfounder99"
  },
  "labels": [
    { "name": "bug", "color": "d73a4a" },
    { "name": "area: vectorstores", "color": "0075ca" }
  ],
  "commentsCount": 7,
  "reactions": { "total": 12, "plusOne": 8, "heart": 2, "rocket": 1 },
  "createdAt": "2026-04-18T11:14:00Z",
  "updatedAt": "2026-04-19T09:02:00Z",
  "matchedKeywords": ["vector"],
  "sourceKind": "search",
  "sourceValue": "langchain vector"
}
```

Every field is ready to drop into a CRM, a Slack channel, or a Notion database.

***

### Pricing

First 2 items per run are free. After that you pay per extracted item. No seats. No tier gating. A 500 item run lands under $1 on the Apify free plan.

***

### FAQ

**How do I pull GitHub issues without an API key?**
Run the actor with no token. GitHub caps anonymous requests at 60 core and 10 search per minute. Fine for small keyword batches or one repo. For a scheduled fleet, generate a free token at `github.com/settings/tokens` and paste it into `githubToken`. Your cap jumps to 5000 core and 30 search per minute. Public data only, no scopes needed.

**Can I monitor pull requests too?**
Yes. Set `itemType` to `prs` for pull requests only, `issues` for issues only, or `all` for both. GitHub returns both from the same endpoint because a pull request is technically an issue with a `pull_request` field attached.

**How do I track one keyword across all of GitHub?**
Use `searchQueries` with GitHub's search syntax. Examples: `"vector database" in:title,body`, `stars:>100 language:python label:bug`, `org:openai type:issue`. The actor passes your query straight to `/search/issues`.

**How do I filter out low star repos?**
Set `minRepoStars`. The actor fetches repo metadata once per repo, caches it, and drops issues from repos under the floor. Useful when you only want signal from production grade users.

**Does it support private repos?**
Yes, if the token you provide has `repo` scope and access. By default the actor uses public data only.

**Does it dedupe across runs?**
Yes. Issue IDs are stored under `SEEN_IDS` in a named key value store. Every run skips seen IDs. Set `dedupe: false` to disable.

**Can I schedule it?**
Yes. Apify Scheduler goes down to 1 minute. Pair with a webhook to push new issues to Slack, Discord, Notion, or your CRM.

**What about GitHub Discussions?**
Discussions are GraphQL only on GitHub's API. This actor covers issues and pull requests via REST for speed. A separate discussions actor is on the roadmap.

**Is pulling GitHub allowed?**
Yes. This actor uses the official GitHub REST API v3, which is rate limited and public by design. No HTML pulling.

***

### Related Scrapemint actors

- **Stack Overflow Lead Monitor** for dev question tracking by tag
- **Hacker News Scraper** for stories and comments by keyword
- **Reddit Lead Monitor** for subreddit and brand mention tracking
- **Product Hunt Launch Tracker** for competitor launch monitoring
- **Upwork Opportunity Alert** for freelance lead generation

Stack these to cover every public developer and customer conversation surface one brand touches.

# Actor input Schema

## `searchQueries` (type: `array`):

Free text queries passed to GitHub's /search/issues endpoint. Supports GitHub search syntax like 'langchain in:title,body', 'stars:>100 language:python label:bug', 'org:openai type:issue'. Leave empty if only watching specific repos below.

## `repos` (type: `array`):

Specific GitHub repos to pull issues from, in the format owner/name. Example: pinecone-io/pinecone-python-client, weaviate/weaviate. Leave empty if only using search queries above.

## `keywords` (type: `array`):

Only items whose title or body contains any of these keywords are kept. Case insensitive. Leave empty to keep everything the search or repo poll returned.

## `itemType` (type: `string`):

Filter by item kind. Issues only excludes pull requests. PRs only returns pull requests. All returns both.

## `state` (type: `string`):

Filter by state. Open is the default. Closed returns closed items. All returns both.

## `labels` (type: `array`):

Only keep items tagged with these labels. Example: bug, help wanted, good first issue. Multiple labels are ANDed together.

## `minRepoStars` (type: `integer`):

Drop issues from repos with fewer than this many stars. Useful when you only want signal from production grade users. Set to 0 to keep everything.

## `maxAgeHours` (type: `integer`):

Skip items created more than this many hours ago. 0 keeps everything regardless of age.

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

Created returns newest first by creation date. Updated returns items most recently updated first.

## `maxItemsPerSource` (type: `integer`):

Per source cap. GitHub pages contain up to 100 items per page and the search endpoint caps at 1000 total results.

## `maxItemsTotal` (type: `integer`):

Hard cap on items pushed to the dataset per run. Controls cost.

## `dedupe` (type: `boolean`):

Skip issue IDs pushed on previous runs. Stored in the key value store under SEEN_IDS. Turn off to return every match on every run.

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

Raises the GitHub API rate limit from 60 core / 10 search per minute (anonymous) to 5000 core / 30 search per minute (authenticated). Generate a free token at github.com/settings/tokens. No scopes required for public data. For private repos, the token needs the repo scope.

## `proxyConfiguration` (type: `object`):

Apify proxy settings. The GitHub REST API is public and rate limited, not IP limited, so a proxy is rarely needed. Add one if your schedule triggers secondary rate limits.

## Actor input object example

```json
{
  "searchQueries": [
    "\"langchain\" in:title,body"
  ],
  "repos": [],
  "itemType": "all",
  "state": "open",
  "labels": [],
  "minRepoStars": 0,
  "maxAgeHours": 168,
  "sortBy": "created",
  "maxItemsPerSource": 50,
  "maxItemsTotal": 200,
  "dedupe": true
}
```

# 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 = {
    "searchQueries": [
        "\"langchain\" in:title,body"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/github-issue-monitor").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 = { "searchQueries": ["\"langchain\" in:title,body"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/github-issue-monitor").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 '{
  "searchQueries": [
    "\\"langchain\\" in:title,body"
  ]
}' |
apify call scrapemint/github-issue-monitor --silent --output-dataset

```

## MCP server setup

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

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/n34lKeGMnUrf5StQp/builds/c27ArgOn6WfgdWrD8/openapi.json