# GitHub Issues & Pull Requests Scraper (`fetch_cat/github-issues-pull-requests-scraper`) Actor

Extract public GitHub issues and pull requests from repositories or search queries for DevRel, support, product, and AI workflows.

- **URL**: https://apify.com/fetch\_cat/github-issues-pull-requests-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 github 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/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

## GitHub Issues & Pull Requests Scraper

Extract public GitHub issues and pull requests from repositories or GitHub search queries.

Use this actor to monitor open-source demand, support pain, competitor roadmaps, bug reports, feature requests, and pull request activity.

### What does GitHub Issues & Pull Requests Scraper do?

This actor turns public GitHub issue and pull request search results into a clean dataset.

It accepts repository names such as `microsoft/vscode`.

It also accepts GitHub issue search queries such as `repo:microsoft/vscode is:issue label:bug`.

The output includes issue and pull request metadata, labels, author details, timestamps, comments, reactions, and source-query provenance.

### Who is it for?

#### DevRel teams

Track what developers ask for across important open-source projects.

#### Product managers

Find repeated bugs, integration gaps, feature requests, and migration pain.

#### Support teams

Monitor public issues mentioning your product, API, SDK, or competitor.

#### Founders and growth teams

Discover high-intent leads from public problems and requests.

#### AI and data teams

Collect structured issue and pull request records for RAG, classification, or trend analysis.

### Why use this actor?

GitHub search is powerful, but manual monitoring is slow.

This actor saves repeatable searches as exportable data.

You can schedule it, connect it to integrations, or call it from code.

You get consistent fields instead of copying records by hand.

### Ready-to-run examples

- [Track open Apify SDK JavaScript issues](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-apify-sdk-js-open-issues)
- [Find Kubernetes good first issues](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-kubernetes-good-first-issues)
- [Monitor open React bug reports](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-bug-reports-react)
- [Review closed VS Code bugs](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-closed-bugs-vscode)
- [Research API rate-limit issues](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-api-rate-limit-issues)
- [Track dependency-update pull requests](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples/github-dependency-update-prs)

[View all 50 ready-to-run examples](https://apify.com/fetch_cat/github-issues-pull-requests-scraper/examples)

### What data can you extract?

| Field | Description |
| --- | --- |
| `repository` | Repository that owns the issue or pull request |
| `type` | `issue` or `pull_request` |
| `number` | GitHub issue or pull request number |
| `title` | Record title |
| `bodyExcerpt` | Short plain-text body excerpt |
| `state` | Open or closed state |
| `url` | Public GitHub URL |
| `apiUrl` | GitHub API URL |
| `authorLogin` | Author username |
| `authorProfileUrl` | Author profile URL |
| `labels` | Label names |
| `assignees` | Assigned usernames |
| `milestone` | Milestone title |
| `commentsCount` | Number of comments |
| `reactions` | Reaction counts |
| `createdAt` | Creation timestamp |
| `updatedAt` | Last update timestamp |
| `closedAt` | Close timestamp |
| `mergedAt` | Merge timestamp when available |
| `sourceQuery` | Query used to find the record |
| `sourceRepository` | Repository input that generated the query |
| `scrapedAt` | Actor scrape timestamp |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | One public GitHub issue or pull request saved to the default dataset. | $0.02905 / 1,000 | $0.02526 / 1,000 | $0.01971 / 1,000 | $0.01516 / 1,000 | $0.01011 / 1,000 | $0.00707 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Input overview

You can use repositories, search queries, or both. If both lists are omitted, the Actor runs the documented `microsoft/vscode` example with the normal `maxItems` limit.

If you provide both, the actor processes all sources in one run until `maxItems` is reached.

#### Repositories

Use repository names in `owner/name` format.

Examples:

- `microsoft/vscode`
- `nodejs/node`
- `facebook/react`

Repository URLs are also accepted.

#### Search queries

Use GitHub issue search syntax.

Examples:

- `repo:microsoft/vscode is:issue label:bug`
- `kubernetes error "good first issue"`
- `org:vercel is:pr state:open`

### Example input

```json
{
  "repositories": ["microsoft/vscode"],
  "searchQueries": [],
  "state": "open",
  "includeIssues": true,
  "includePullRequests": true,
  "labels": [],
  "maxItems": 25
}
```

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Repositories | `repositories` | array, up to 100 | Public GitHub repositories as `owner/name` or repository URLs. If both source lists are omitted, `microsoft/vscode` is used. |
| Search queries | `searchQueries` | array, up to 100 | Raw GitHub issue-search queries. Repository and query inputs can be combined. |
| State | `state` | `open` by default | Include `open`, `closed`, or `all` records. A conflicting state already written in a raw query fails clearly. |
| Include issues | `includeIssues` | boolean, default `true` | Include issue records. |
| Include pull requests | `includePullRequests` | boolean, default `true` | Include pull request records. |
| Labels | `labels` | array, up to 50 | Label filters appended to generated searches. |
| Updated since | `since` | date string | Include records updated on or after this date. |
| Maximum records | `maxItems` | integer, default `20` | Total saved-row limit across all sources; each GitHub search query is capped at 1,000 matches. |
| GitHub token | `githubToken` | secret string | Optional token for higher GitHub API rate limits on public-data runs. |

#### Search filters

#### State

Choose `open`, `closed`, or `all`.

#### Include issues

Enable this to save GitHub issues.

#### Include pull requests

Enable this to save GitHub pull requests.

#### Labels

Add label names such as `bug`, `documentation`, or `good first issue`.

The actor appends these filters to generated repository searches.

#### Updated since

Use `since` to collect records updated after a date.

This is useful for scheduled monitoring.

### Output example

```json
{
  "repository": "microsoft/vscode",
  "type": "issue",
  "number": 123,
  "title": "Example issue title",
  "state": "open",
  "url": "https://github.com/microsoft/vscode/issues/123",
  "authorLogin": "octocat",
  "labels": ["bug"],
  "commentsCount": 4,
  "createdAt": "2026-01-01T00:00:00Z",
  "updatedAt": "2026-01-02T00:00:00Z"
}
```

### How to scrape a repository

1. Open the actor input form.
2. Add one or more repositories.
3. Choose state and issue / pull request options.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### How to monitor a keyword

1. Add a GitHub search query.
2. Include words, labels, organizations, or repositories.
3. Set `since` for incremental monitoring.
4. Schedule the actor daily or weekly.
5. Send new rows to your destination system.

### Tips for better results

💡 Use repository-specific queries for precise output.

💡 Use labels to focus on bugs, feature requests, or onboarding tasks.

💡 Use `since` for recurring jobs so each run stays small.

💡 Start with `maxItems: 25` before scaling up.

💡 Add a GitHub token only when you need higher rate limits.

### Rate limits

Public GitHub data can be fetched without a token for small runs.

GitHub applies rate limits to unauthenticated API usage.

For larger monitoring workflows, provide a GitHub token in the optional secret input.

The token is used only to request public API data with a higher rate limit.

GitHub search returns at most 1,000 matches for each query. `maxItems` remains a total cap across all sources, so larger values are useful only when you provide multiple repositories or search queries. Each run stores a `RUN_SUMMARY` key-value record that identifies incomplete search results and sources that may have reached the per-query cap.

Invalid GitHub search queries and conflicting state filters fail clearly instead of returning a successful empty dataset. If GitHub rate limits a request, the actor retries a bounded number of times and then fails with guidance to wait or provide `githubToken`.

GitHub search returns at most 1,000 matches for each query. `maxItems` remains a total cap across all sources, so larger values are useful only when you provide multiple repositories or search queries. Each run stores a `RUN_SUMMARY` key-value record that identifies incomplete search results and sources that may have reached the per-query cap.

Invalid GitHub search queries and conflicting state filters fail clearly instead of returning a successful empty dataset. If GitHub rate limits a request, the actor retries a bounded number of times and then fails with guidance to wait or provide `githubToken`.

### Integrations

Send dataset rows to Google Sheets for manual review.

Send issue records to Slack or Discord for support triage.

Load pull request data into a warehouse for engineering analytics.

Use webhooks to trigger workflows when new matching issues appear.

Feed output into LLM classification or RAG pipelines.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/github-issues-pull-requests-scraper').call({
  repositories: ['microsoft/vscode'],
  state: 'open',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/github-issues-pull-requests-scraper').call(run_input={
    'repositories': ['microsoft/vscode'],
    'state': 'open',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~github-issues-pull-requests-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"repositories":["microsoft/vscode"],"state":"open","maxItems":25}'
```

### MCP usage

You can run this actor from Apify MCP tools.

Use this tool URL pattern:

`https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper`

Add it to Claude Code with:

```bash
claude mcp add apify-github-issues "https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper"
```

For a JSON MCP configuration, use:

```json
{
  "mcpServers": {
    "apify-github-issues": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper"
      ]
    }
  }
}
```

#### Example MCP prompts

Use these prompts after connecting the actor through MCP.

Example prompt ideas:

#### Claude Code prompt

"Use the Apify GitHub Issues & Pull Requests Scraper tool for microsoft/vscode and summarize the top open bugs."

#### Claude Desktop prompt

"Use the MCP GitHub issues scraper to find recent open pull requests in nodejs/node and group them by likely topic."

#### Agent workflow prompt

"With the Apify MCP tool, monitor GitHub issues mentioning our SDK every day and send high-priority records to Slack."

### Common workflows

#### Competitive intelligence

Track public issues in competitor repositories.

Look for bug patterns, integration gaps, and roadmap signals.

#### DevRel monitoring

Find developers asking for help with your ecosystem.

Prioritize responses by comments, labels, or recency.

#### Product discovery

Collect feature requests and pain points from open-source communities.

Classify titles and body excerpts with your preferred AI model.

#### Engineering analytics

Export pull request metadata for reporting on activity and review flow.

Combine with other GitHub or CI data sources.

### Troubleshooting

#### The run says GitHub rate limit reached

Use a smaller `maxItems`, wait for the reset window, or provide a GitHub token.

#### My query returns no data

Check the query in GitHub search first, then copy the same syntax into `searchQueries`.

#### I only want issues, not pull requests

Set `includeIssues` to `true` and `includePullRequests` to `false`.

#### I only want pull requests

Set `includeIssues` to `false` and `includePullRequests` to `true`.

### Data quality notes

The actor returns public GitHub metadata available through GitHub search.

Some fields may be empty when GitHub does not provide that value.

Body text is saved as an excerpt to keep rows compact.

Use `url` to open the full public issue or pull request.

### Legality and responsible use

This actor extracts public GitHub issue and pull request data.

You are responsible for using the data in accordance with GitHub's terms, privacy expectations, and applicable laws.

Do not use the output for spam, harassment, or abusive automation.

Respect users and project maintainers.

### Related actors

Explore related Apify actors from `fetch_cat` for developer intelligence and open-source research.

- [GitHub Profile Scraper](https://apify.com/fetch_cat/github-profile-scraper)
- [GitHub Repository Search Scraper](https://apify.com/fetch_cat/github-repository-search-scraper)
- [GitHub Trending Scraper](https://apify.com/fetch_cat/github-trending-scraper)
- [GitHub Contributor Email Scraper](https://apify.com/fetch_cat/github-contributor-email-scraper)

Use GitHub issue data together with other public web datasets to enrich product and market research.

### FAQ

#### Does this require a GitHub account?

No for small public-data runs.

A token is optional for higher rate limits.

#### Can it access private repositories?

No. This actor is designed for public GitHub issues and pull requests.

#### Can I schedule it?

Yes. Use Apify schedules and the `since` field for recurring monitoring.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, or through the API.

#### Can I scrape comments?

The first version saves comment counts, not full comment threads.

#### Can I combine multiple repositories?

Yes. Add multiple repository names to `repositories`.

#### Can I combine repositories and search queries?

Yes. The actor processes both input sources in one run.

### Support

Report a bug from the Actor page when a run fails or the output looks wrong. Include:

- Run ID or run URL
- Input JSON
- Expected output
- Actual output
- One reproducible public URL or repository/search query

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

Public GitHub repositories to search, in owner/name form or as repository URLs.

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

Optional raw GitHub issue search queries, for example: repo:microsoft/vscode is:issue label:bug. Repository and query inputs are combined into one run.

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

Issue or pull request state to include.

## `includeIssues` (type: `boolean`):

Include GitHub issues in the output.

## `includePullRequests` (type: `boolean`):

Include GitHub pull requests in the output.

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

Optional GitHub label filters appended to generated searches, for example bug or good first issue.

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

Only include issues or pull requests updated on or after this date. Use YYYY-MM-DD or an ISO date string.

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

Maximum number of dataset rows to save across all repositories and search queries.

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

Optional GitHub personal access token for higher API rate limits. Public data works without a token for small runs.

## Actor input object example

```json
{
  "repositories": [
    "microsoft/vscode"
  ],
  "searchQueries": [],
  "state": "open",
  "includeIssues": true,
  "includePullRequests": true,
  "labels": [],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "repositories": [
        "microsoft/vscode"
    ],
    "searchQueries": [],
    "labels": [],
    "since": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/github-issues-pull-requests-scraper").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": ["microsoft/vscode"],
    "searchQueries": [],
    "labels": [],
    "since": "",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/github-issues-pull-requests-scraper").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 '{
  "repositories": [
    "microsoft/vscode"
  ],
  "searchQueries": [],
  "labels": [],
  "since": ""
}' |
apify call fetch_cat/github-issues-pull-requests-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Sr5MKDJMKMcsmcXme/builds/NB4gZkKeaY4MLsn7l/openapi.json