# GitHub Issues Scraper (`automly/github-issues-pr-monitor`) Actor

Track GitHub issues and pull requests across repositories, organizations, users or searches: new, updated, closed and merged items with title, state, labels, author, dates and links. Export to CSV, JSON or Excel, schedule runs or use the API.

- **URL**: https://apify.com/automly/github-issues-pr-monitor.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 issue or pull requests

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 Issues Scraper - Issues & Pull Requests Monitor

### What is GitHub Issues Scraper?

**GitHub Issues Scraper** is a tool that lets you **scrape and monitor issues and pull requests from GitHub**: title, full text, state, merged status and dates, author, labels, assignees, milestone, comment and reaction counts, for any repository, organization, user or GitHub search. Add the repositories you care about, click **Start**, and download the issues and pull requests as Excel, CSV or JSON.

- 🔔 **Monitoring:** turn on incremental monitoring and each run returns only what changed since the last one
- 🗂️ **Any source:** repositories, whole organizations, users or your own GitHub issue searches, mixed in one run
- 🔓 **No login:** no GitHub account or key needed for public repositories
- 💸 **Free to try:** the $5 of free usage every Apify account gets each month covers about 10,000 issues or pull requests

### What can GitHub Issues Scraper do?

- Scrape GitHub issues from any public repository
- Scrape GitHub pull requests with merged status and merge date
- Monitor all issues and pull requests across a GitHub organization
- Track the issues and pull requests a GitHub user opens
- Filter GitHub issues by label, such as `bug` or `good first issue`
- Get open, closed or all GitHub issues updated since a date
- Monitor new GitHub issues on a schedule without getting the same ones twice
- Export GitHub issues and pull requests to Excel, CSV, JSON, HTML or XML

### What data can you extract from GitHub issues and pull requests?

| | | |
|---|---|---|
| 📝 Title | 📄 Full text (Markdown) and one-line summary | 🔀 Issue or pull request |
| 🟢 State (open or closed) | ✅ Merged status | 📅 Created, updated, closed and merged dates |
| 👤 Author | 🏷️ Labels | 🙋 Assignees |
| 🎯 Milestone | 💬 Comment count | 👍 Reaction count |
| 📦 Repository and owner | 📝 Draft and locked flags | 🔗 Link to the issue or pull request |

### How to scrape GitHub issues and pull requests

1. [Create a free Apify account](https://console.apify.com/sign-up) (no credit card needed).
2. Open **GitHub Issues Scraper**.
3. Add **Repositories** (`owner/repo` or a GitHub link), **Organizations**, **Users** or **Search queries**.
4. Choose **Item kinds** and **State**, add **Labels** or **Updated since** if you want, set **Max items** and click **Start**.
5. When the run finishes, download your issues and pull requests as Excel, CSV, JSON, HTML or XML.

### How much does it cost to scrape GitHub issues?

From 15 October 2026 you pay **$0.50 per 1,000 issues or pull requests**, on every Apify plan. Apify platform usage is included in this price, so there is nothing else to pay for the run. Until then, see the **Pricing** tab for the current terms.

For example, from 15 October 2026 a monitor that returns 1,000 new or updated issues and pull requests in a month costs $0.50 on the Free plan, and the same on every other plan.

Every Apify account gets **$5 of free usage each month**. See the **Pricing** tab for details.

### ⬇️ Input

Combine sources freely: for example, two repositories, a whole organization and a custom search in one run.

| Setting | What it does |
|---|---|
| Repositories | Repositories to monitor, as `owner/repo` or a full GitHub URL |
| Organizations | Organization logins, to monitor all their public repositories |
| Users | User logins whose issues and pull requests to monitor |
| Search queries | Your own GitHub issue searches, e.g. `repo:apify/crawlee label:bug` or `org:microsoft vscode in:title` |
| Item kinds | `issues`, `pullRequests` or `both` (default `both`) |
| State | `open`, `closed` or `all` (default `open`) |
| Updated since (ISO datetime) | Only items updated at or after this time, e.g. `2024-01-01T00:00:00Z` |
| Labels | Only items that carry all of these labels |
| Max items | Total items to collect across all sources (default 50, up to 1,000) |
| Include comment count | Add the number of comments to each item (on by default) |
| Include labels | Add the label names to each item (on by default) |
| Include reactions | Add the total reaction count to each item (off by default) |
| Incremental monitoring (checkpoint) | Remember the latest activity per source and return only newer items next run |
| Pause between steps, connection settings and your own GitHub key | Optional. The defaults work for most runs |

Example: open issues and pull requests in one repository and one organization, updated in 2024 or later.

```json
{
  "repositories": ["apify/apify-sdk-python"],
  "organizations": ["apify"],
  "itemKinds": "both",
  "state": "open",
  "since": "2024-01-01T00:00:00Z",
  "maxItems": 100,
  "includeCommentsCount": true,
  "includeReactions": true
}
```

Example: a daily bug monitor that returns only new activity.

```json
{
  "searchQueries": ["repo:apify/crawlee label:bug"],
  "state": "all",
  "useStateCheckpoint": true,
  "maxItems": 200
}
```

### ⬆️ Output

You get one row per issue or pull request. `itemKind` says which one it is, and `sourceKind` plus `monitorQuery` show which of your sources found it. You can view the rows as a table in Apify Console or download them as Excel, CSV, JSON, HTML or XML.

```json
{
  "sourceKind": "repository",
  "monitorQuery": "apify/apify-sdk-python",
  "repository": "apify/apify-sdk-python",
  "owner": "apify",
  "itemKind": "issue",
  "itemId": 3674179687,
  "itemNumber": 692,
  "itemUrl": "https://github.com/apify/apify-sdk-python/issues/692",
  "title": "Publish to conda-forge",
  "bodyText": "Blocked by:\n- https://github.com/apify/apify-client-python/issues/545\n- https://github.com/apify/crawlee-python/issues/104  (Old version in review, will need to be updated to match latest version)",
  "summary": "Blocked by: - https://github.com/apify/apify-client-python/issues/545 - https://github.com/apify/crawlee-python/issues/104 (Old version in review, will need to be updated to match latest version)",
  "state": "open",
  "isMerged": false,
  "createdAt": "2025-11-28T09:16:31Z",
  "updatedAt": "2025-11-28T09:16:39Z",
  "closedAt": null,
  "mergedAt": null,
  "authorLogin": "Pijukatel",
  "labels": ["t-tooling"],
  "assignees": ["Pijukatel"],
  "commentsCount": 0,
  "reactionsCount": null,
  "milestone": null,
  "isDraft": null,
  "isLocked": false,
  "fetchedAt": "2026-09-27T18:19:52Z"
}
```

| Field | Description |
| --- | --- |
| `sourceKind` | `repository`, `organization`, `user` or `searchQuery` |
| `monitorQuery` | The source that found the item |
| `repository` | Full `owner/repo` name |
| `owner` | Repository owner login |
| `itemKind` | `issue` or `pullRequest` |
| `itemId` | GitHub global identifier |
| `itemNumber` | Issue or pull request number in the repository |
| `itemUrl` | Link to the issue or pull request on GitHub |
| `title` | Title |
| `bodyText` | Full text (Markdown) |
| `summary` | One-line summary of the text |
| `state` | `open` or `closed` |
| `isMerged` | `true` when a pull request has been merged |
| `createdAt` / `updatedAt` / `closedAt` / `mergedAt` | Activity dates |
| `authorLogin` | Login of the author |
| `labels` | Label names |
| `assignees` | Assignee logins |
| `commentsCount` | Number of comments (when included) |
| `reactionsCount` | Total reactions (when included) |
| `milestone` | Milestone title, if any |
| `isDraft` | `true` for draft pull requests |
| `isLocked` | `true` when the conversation is locked |
| `fetchedAt` | When the record was collected |

### How to monitor new GitHub issues and pull requests

There are two ways to get only fresh activity each run:

1. Set **Updated since** to the time of your last run.
2. Or turn on **Incremental monitoring (checkpoint)**. The actor remembers the latest activity per source and returns only newer items next time. An explicit **Updated since** always takes precedence.

Then [schedule the actor](https://docs.apify.com/platform/schedules) to run every hour or every day, and send the new items to Slack, email or a spreadsheet with an [integration](https://apify.com/integrations).

### How can I use GitHub issues data?

- **Developer relations:** keep an eye on issues and pull requests across the repositories your community depends on
- **Security triage:** watch for newly opened issues or pull requests that mention security topics
- **Competitive tracking:** follow activity in competitors' open-source projects
- **Open-source maintenance:** track incoming issues and pull requests across a whole organization
- **Sales and lead signals:** find people opening issues or pull requests around topics you sell into

### Scrape more GitHub and developer data

| Actor | What it gets |
|---|---|
| [GitHub Repository Scraper - Repos, Issues & Pull Requests](https://apify.com/automly/github-repo-scraper) | Repository details, open issues, pull requests and contributor profiles |
| [GitHub Users Scraper - Developers by Location & Company](https://apify.com/automly/github-users-search-api) | GitHub users and organizations by keyword, location, company and follower count |
| [GitHub Code Search API](https://apify.com/automly/github-code-search-api) | Public code files that match your search, with repository details |
| [PyPI Release Monitor - New Python Package Versions](https://apify.com/automly/pypi-release-monitor-api) | New versions of the Python packages you follow |
| [Docker Hub Scraper - Image Tags & Release Monitor](https://apify.com/automly/docker-hub-tag-monitor-api) | New Docker Hub image tags and releases |
| [Hacker News Scraper - Stories, Comments & Trends](https://apify.com/automly/hacker-news-trends-api) | Hacker News stories and discussions by keyword, points and date |

### ❓FAQ

#### How much does it cost to monitor GitHub issues?

From 15 October 2026 it costs $0.50 per 1,000 issues or pull requests, with platform usage included. See the cost section above and the **Pricing** tab.

#### Do I need a GitHub account or key?

No. Public repositories need no GitHub account, login or key, whatever the size or schedule of your runs. You can add your own GitHub key in the optional settings if you also want private repositories that your key can see.

#### How many issues can I get per run?

Up to 1,000 per run (**Max items**). Organization, user and search sources return up to 1,000 of the most recent matches each. If a very large run ends early, it keeps everything it collected up to that point.

#### Is a pull request counted as an issue?

On GitHub a pull request is a kind of issue. This actor marks each row clearly as `issue` or `pullRequest`, and **Item kinds** lets you get only one of them.

#### Can I get closed and merged pull requests?

Yes. Set **State** to `closed` or `all`. Merged pull requests have `isMerged: true` and a `mergedAt` date.

#### Can I connect GitHub Issues Scraper to other tools or AI agents?

Yes. Start runs and download results with the Apify API or the Python and JavaScript clients, send results to Make, Zapier, n8n, Google Sheets or Slack with Apify integrations and webhooks, or let AI assistants and agents run it through the Apify MCP server at [mcp.apify.com](https://mcp.apify.com).

#### Is it legal to scrape GitHub?

This actor only collects issues and pull requests that are public on GitHub. They can still contain personal data, such as usernames, which may be protected by laws such as GDPR, so only scrape it for a legitimate reason and ask a lawyer if you are unsure. You can read more in [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

GitHub Issues Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by GitHub.

#### Something isn't working?

Open the **Issues** tab and tell us your input and what you expected.

### ⭐ Your feedback

Have an idea or found a problem? Tell us on the **Issues** tab. If GitHub Issues Scraper saved you time, a short review on the **Reviews** tab helps other people find it.

# Actor input Schema

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

Repositories to monitor, as 'owner/repo' (e.g. 'apify/apify-sdk-python') or a full GitHub URL. Each repository is listed directly, returning both issues and pull requests.

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

Organization logins to monitor across all of their public repositories (e.g. 'apify'). Uses GitHub search, which returns up to 1000 most recent matches.

## `users` (type: `array`):

User logins whose issues and pull requests should be monitored (e.g. 'octocat'). Uses GitHub search, which returns up to 1000 most recent matches.

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

Raw GitHub issue-search queries for advanced monitoring, e.g. 'repo:apify/crawlee label:bug' or 'org:microsoft vscode in:title'. Item kind, state, and 'since' qualifiers are added automatically when not already present.

## `itemKinds` (type: `string`):

Which kinds of items to collect. One of: 'issues', 'pullRequests', or 'both'.

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

Which item state to collect. One of: 'open', 'closed', or 'all'.

## `since` (type: `string`):

Only collect items updated at or after this ISO-8601 timestamp, e.g. '2024-01-01T00:00:00Z'. Leave empty to collect the most recent items. Great for recurring monitoring runs.

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

Only collect items carrying all of these labels (e.g. 'bug', 'good first issue'). Leave empty to ignore labels.

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

Maximum total number of items to collect across all sources (1-1000).

## `includeCommentsCount` (type: `boolean`):

Include the number of comments on each item.

## `includeLabels` (type: `boolean`):

Include the list of label names on each item.

## `includeReactions` (type: `boolean`):

Include the total reaction count on each item.

## `useStateCheckpoint` (type: `boolean`):

Remember the latest 'updated' time per source between runs and only collect newer items on the next run. An explicit 'since' value always takes precedence.

## `requestDelayMs` (type: `integer`):

Pause between steps, in milliseconds. The default works for most runs.

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

Optional. Not needed: the actor works without a token. Add your own GitHub token if you prefer; it also gives access to private repositories your token can see.

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

Optional proxy configuration. Useful for very large or frequent runs; the GitHub API works fine over a direct connection for most use cases.

## Actor input object example

```json
{
  "repositories": [
    "apify/apify-sdk-python"
  ],
  "itemKinds": "both",
  "state": "open",
  "maxItems": 50,
  "includeCommentsCount": true,
  "includeLabels": true,
  "includeReactions": false,
  "useStateCheckpoint": false,
  "requestDelayMs": 250
}
```

# Actor output Schema

## `items` (type: `string`):

All issues and pull requests produced by this run.

# 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 = {
    "repositories": [
        "apify/apify-sdk-python"
    ],
    "itemKinds": "both",
    "state": "open"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/github-issues-pr-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 = {
    "repositories": ["apify/apify-sdk-python"],
    "itemKinds": "both",
    "state": "open",
}

# Run the Actor and wait for it to finish
run = client.actor("automly/github-issues-pr-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 '{
  "repositories": [
    "apify/apify-sdk-python"
  ],
  "itemKinds": "both",
  "state": "open"
}' |
apify call automly/github-issues-pr-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automly/github-issues-pr-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/zDESvqZz2offj5LVY/builds/o0hvd3s9x4E52k4gH/openapi.json