# GitHub Repo Monitor — Releases, Stars, Issues & Activity (`vertaizen/github-repo-monitor`) Actor

OSS monitoring tool tracking any GitHub repos via the open GitHub REST API — new releases, star velocity, issues, commits & contributors. No scraping, no blocking. Monitor mode returns only NEW activity for release alerts & devtools competitive intel. MCP-ready.

- **URL**: https://apify.com/vertaizen/github-repo-monitor.md
- **Developed by:** [Diego Moragues](https://apify.com/vertaizen) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 items

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 Repo Monitor — Release Tracker, Star Velocity & Activity Alerts

**GitHub Repo Monitor** is a fast, reliable **GitHub release tracker** and **OSS monitoring** tool that watches any list of public GitHub repositories — **new releases, star velocity, issues, commits and contributors** — using the **open GitHub REST API**. No scraping, no browser, no proxies, nothing to get blocked. Point it at your dependency list, your competitors' repos, or a VC watchlist, and get clean, structured JSON in seconds. Turn on **monitor mode** and each scheduled run returns only what changed since the last run — perfect for **release alerts**, **star-velocity tracking**, and **competitive intelligence** on open-source projects.

If you care about **GitHub monitoring**, **devtools competitive intel**, **dependency tracking**, **release notifications**, or turning open-source activity into **buying and growth signals**, this actor is for you.

### Why this actor is reliable

It talks **only to the public GitHub REST API** (`api.github.com`) — the same API GitHub officially documents and supports. Requests are simple JSON `GET`s with proper `User-Agent` and `Accept` headers. There are **no CAPTCHAs, no WAFs, no IP blocks and no brittle HTML parsing**. The anonymous rate limit is 60 requests/hour; add an optional **GitHub token** and it jumps to **5000 requests/hour**. When the limit is reached, the actor reads GitHub's `x-ratelimit-remaining` / `x-ratelimit-reset` headers and **stops politely** — it never hammers the API and never charges you for a request that didn't return data.

| | **This GitHub Repo Monitor (REST API)** | GitHub-trending / HTML scrapers | Watching repos by hand |
|---|---|---|---|
| Release tracking | ✅ Per-repo, monitor mode | Rare | Manual |
| Star velocity (`starsDelta`) | ✅ Computed each run | ❌ | ❌ |
| Issues / commits / contributors | ✅ Selectable | Limited | Manual |
| Blocking / CAPTCHAs | ❌ Official API | ✅ Possible | — |
| Only NEW activity on later runs | ✅ | ❌ | — |
| Rate-limit handling | ✅ Reads headers, stops politely | Varies | — |

### What you get for each item

A **release**:

```json
{
  "repo": "apify/crawlee",
  "type": "release",
  "id": 178654321,
  "tagName": "v3.11.0",
  "name": "Crawlee 3.11",
  "publishedAt": "2026-06-20T10:00:00Z",
  "url": "https://github.com/apify/crawlee/releases/tag/v3.11.0",
  "isPrerelease": false,
  "isNew": true,
  "checkedAt": "2026-07-02T09:00:00Z"
}
```

A **repo snapshot** (stars/forks/etc., always emitted, with `starsDelta` vs. the previous run):

```json
{
  "repo": "facebook/react",
  "type": "repo-snapshot",
  "stars": 231480,
  "forks": 47200,
  "openIssues": 980,
  "watchers": 6400,
  "language": "JavaScript",
  "pushedAt": "2026-07-01T18:22:10Z",
  "description": "The library for web and native user interfaces.",
  "url": "https://github.com/facebook/react",
  "starsDelta": 152,
  "checkedAt": "2026-07-02T09:00:00Z"
}
```

An **issue**:

```json
{
  "repo": "facebook/react",
  "type": "issue",
  "number": 31245,
  "title": "Bug: hydration mismatch with Suspense",
  "state": "open",
  "author": "octocat",
  "createdAt": "2026-06-30T14:58:31Z",
  "url": "https://github.com/facebook/react/issues/31245",
  "isNew": true,
  "checkedAt": "2026-07-02T09:00:00Z"
}
```

Commits and contributors follow the same clean, flat shape.

### How to use it

1. **Add repositories** — as `owner/repo` (e.g. `facebook/react`) or full GitHub URLs (e.g. `https://github.com/apify/crawlee`).
2. **Pick what to track** — `releases`, `stars`, `issues`, `commits`, `contributors` (default: releases + stars).
3. **(Optional) Add a GitHub token** — raises the rate limit from 60 to 5000 req/hr. It is stored as a secret.
4. **(Optional) Enable monitor mode** — and schedule the actor (e.g. hourly or daily). Each run returns only NEW activity per repo. Wire an Apify **webhook** to push new releases/issues straight to Slack, email, or your CRM.

### Use cases

Each of these is a real search buyers make:

- **"Get a Slack alert for new GitHub releases"** — schedule the actor in monitor mode with a webhook so a new release in any tracked repo lands in Slack or email the moment it ships.
- **"Track competitor OSS and star velocity"** — monitor a rival's repos for releases, issue volume, contributor growth, and daily `starsDelta` as a live competitive-intel feed.
- **"Monitor dependencies for new releases and security issues"** — watch the repos behind your critical dependencies so upgrades and security-relevant issues are never a surprise.
- **"Spot accelerating open-source projects for VC deal flow"** — track daily star velocity across a watchlist to catch projects breaking out before the market notices.
- **"Feed GitHub activity to an AI agent"** — pipe releases and issues into an LLM workflow via the Apify MCP server.

#### Track competitor OSS & star velocity

The sharpest competitive-intel use: add a competitor's repositories, track `stars` + `releases` + `issues` in monitor mode, and every run gives you their release cadence, their issue backlog trend, and — via `starsDelta` — exactly how fast their community is growing day over day. It's a public, real-time read on a rival's open-source momentum.

### Pricing

**Pay per item** delivered — no subscription, no minimum. You only pay for the releases, snapshots, issues, commits and contributors actually pushed to your dataset. Repos that 404 or fail are recorded in the run's key-value store and **never charged**.

### FAQ

#### Which GitHub data can it track?

Five signals per repository: **releases**, **stars** (a full repo snapshot: stars, forks, open issues, watchers, language, last push, description, plus `starsDelta`), **issues** (pull requests excluded), **commits**, and **contributors**. Choose any combination in the `track` input.

#### How do I get Slack or Discord alerts for new GitHub releases?

Enable `monitorMode`, track `releases`, schedule the actor (e.g. hourly), and attach an Apify [webhook or integration](https://docs.apify.com/platform/integrations) to the run. Each new release is pushed to Slack, Discord, email, or your CRM the moment it appears — a hosted alternative to polling the GitHub releases page yourself.

#### Do I need a GitHub token?

No. The actor works anonymously at GitHub's 60 requests/hour limit — enough to monitor a handful of repos. For larger watchlists or frequent scheduled runs, add a **read-only** personal access token to raise the limit to 5000 requests/hour. The token is stored as a secret input. See the [GitHub REST API rate-limit docs](https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api).

#### How does monitor mode work?

With `monitorMode` enabled, the actor keeps a per-repo record of previously seen release/issue/commit/contributor IDs in a persistent named key-value store (`GITHUB-MONITOR-STATE`). On each run it compares current activity against that record and outputs only the new items (`isNew: true`). The first run for a repo is a **baseline** (it records what already exists and pushes nothing). Repo snapshots are always emitted and carry a `starsDelta` computed against the previous run.

#### What happens when the rate limit is hit?

The actor reads GitHub's `x-ratelimit-remaining` and `x-ratelimit-reset` headers. When the limit is exhausted it **stops politely**, records a `RATE_LIMIT` note (with the reset time and a hint to add a token) in the run's key-value store, and keeps every item already delivered. It never spins on a rate-limited API.

#### What happens if a repo doesn't exist?

A repository that returns 404 (typo, private, or deleted) is recorded in the `FAILED` record of the run's key-value store and in the run log, and **you are never charged** for it. The rest of your list continues processing normally.

#### Is this legal / allowed?

Yes. The actor reads the **public, official [GitHub REST API](https://docs.github.com/en/rest)** using a proper `User-Agent` and honoring GitHub's documented rate limits. No login is required for public repositories, no private data is accessed, and no rate-limit abuse occurs.

#### Can AI agents use this actor?

Absolutely. The input schema is flat and agent-friendly, and every Apify actor is consumable via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), so AI agents and LLM pipelines can call this as a tool to monitor open-source repositories autonomously.

# Actor input Schema

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

GitHub repositories to monitor. Use `owner/repo` (e.g. `facebook/react`) or full GitHub URLs (e.g. `https://github.com/apify/crawlee`).

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

Optional GitHub personal access token. Raises the API rate limit from 60 to 5000 requests/hour. A read-only classic token or fine-grained token with public-repo read access is enough. Leave empty to use the anonymous 60 req/hr limit.

## `track` (type: `array`):

Which signals to collect per repository.

## `monitorMode` (type: `boolean`):

When enabled, the actor remembers previously seen releases, issues, commits and contributors per repository (in a persistent named key-value store) and only outputs items that appeared since the last run. Ideal for scheduled runs with webhook alerting (Slack, email, CRM). Repo snapshots (stars/forks) are always emitted and carry a `starsDelta` vs. the previous run.

## `maxItemsPerRepo` (type: `integer`):

Safety cap on the number of releases / issues / commits / contributors returned per repository.

## Actor input object example

```json
{
  "repos": [
    "apify/crawlee",
    "facebook/react"
  ],
  "track": [
    "releases",
    "stars"
  ],
  "monitorMode": false,
  "maxItemsPerRepo": 100
}
```

# 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 = {
    "repos": [
        "apify/crawlee",
        "facebook/react"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vertaizen/github-repo-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 = { "repos": [
        "apify/crawlee",
        "facebook/react",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vertaizen/github-repo-monitor").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 '{
  "repos": [
    "apify/crawlee",
    "facebook/react"
  ]
}' |
apify call vertaizen/github-repo-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vertaizen/github-repo-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Vajj99yrcTmaz7R2K/builds/1T7Ig6deQLAUOjDxn/openapi.json