# GitHub Release Monitor (`arched_friend/github-release-monitor`) Actor

Watch any list of GitHub repositories and get every new release the day it ships, with its version, changelog and assets. Tracks stars, forks and open issues alongside, so you can see a dependency stalling or a competitor accelerating.

- **URL**: https://apify.com/arched\_friend/github-release-monitor.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 repository checkeds

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 Release Monitor: Know the Day a Dependency Ships

Watch any list of GitHub repositories and get every new release as it happens — the version, the changelog, the author and the assets. Stars, forks, open issues and days since the last push come alongside, so you can see a dependency stalling or a competitor accelerating.

Built for engineering teams tracking what they depend on, and for anyone who currently finds out about a breaking release from a failing build.

### How it works

```mermaid
flowchart LR
    A["owner/repo list"] --> B["GitHub REST API"]
    B --> C["Releases + repo stats"]
    C --> D{"Seen last run?"}
    D -->|no| E["new"]
    D -->|yes| F["seen"]
    E --> G[("Release feed")]
    C --> H["stars, forks, issues,<br/>days since last push"]
```

No scraping: this reads GitHub's documented public API, so it does not break when GitHub restyles a page and it needs no proxy or browser.

### Built for

- **Engineering teams** tracking the libraries they depend on
- **Security and platform teams** who need to see a patch release the day it lands
- **Developer-tool companies** watching competitors and the wider ecosystem
- **Technical investors** reading release cadence and issue counts as health signals

### Input

```json
{
  "repositories": [
    "apify/crawlee",
    "facebook/react",
    "https://github.com/vercel/next.js"
  ],
  "onlyNew": true
}
```

| Setting | What it does |
| --- | --- |
| `repositories` | `owner/name` or any GitHub URL, mixed freely |
| `githubToken` | Optional. Raises the rate limit from 60/hour to 5,000 |
| `onlyNew` | Return only releases not seen last run |
| `includePrereleases` | Include RCs, betas and alphas. Off by default |
| `tagContains` / `tagExcludes` | Narrow to a major line, or drop nightlies |
| `includeRepoStats` | Also fetch stars, forks, issues and last-push age |

### About the rate limit

GitHub allows **60 requests an hour** from an unauthenticated client, which is roughly 30 repositories per run with stats on. A free personal access token with **no scopes at all** raises that to 5,000.

If the limit is hit, the run stops cleanly and says so in the summary rather than grinding through a wall of 403s and reporting an empty result as though nothing had shipped.

### Output

```json
{
  "repo": "apify/crawlee",
  "tag": "v3.18.1",
  "name": "v3.18.1",
  "version": { "major": 3, "minor": 18, "patch": 1, "prerelease": null },
  "bumpType": "patch",
  "isPrerelease": false,
  "publishedAt": "2026-09-09T11:02:31Z",
  "author": "B4nan",
  "assetCount": 0,
  "body": "### Bug Fixes\n* handle session rotation on 403 ...",
  "url": "https://github.com/apify/crawlee/releases/tag/v3.18.1",
  "changeType": "new",
  "checkedAt": "2026-09-17T18:21:09.884Z"
}
```

`bumpType` is computed against the release below it, so you can filter for `major` and get only the releases that are likely to break something.

The changelog is kept in `body` rather than reduced to a link, because the changelog is the reason anyone watches releases in the first place.

### Turn it into a release alert

```json
{
  "repositories": ["apify/crawlee", "apify/apify-sdk-js"],
  "onlyNew": true
}
```

Schedule it hourly. The first run records the release history without alerting; every run after returns only what actually shipped.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~github-release-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "repositories": ["facebook/react"],
    "onlyNew": true
  }'
```

### Pricing

You pay $0.005 for each repository checked, however many releases it has.

| Watching 40 repos hourly | Monthly cost |
| --- | --- |
| Reading release feeds by hand | not realistically possible |
| Dependency monitoring suites | $50 to $300 per month |
| This Actor | around $144 per month, or $6 per month once a day |

### Common questions

**Why did the first run return everything without alerting?** Because a first run has no baseline, and firing an alert for a decade of release history would be useless. Those rows are labelled `first-run`; the run after that is when `new` starts meaning something.

**Can it watch private repositories?** Yes, with a token that can read them. Without one they come back as `not-found`, which is what GitHub reports for anything the caller cannot see.

**Does it track commits or tags?** No. It watches published releases, which is where maintainers put the changelog. A repo that never cuts releases returns nothing.

**Is my token stored?** It is passed per run as a secret input and used only for the `Authorization` header on GitHub calls.

### Related products

- **Tech Stack Checker** to find which libraries a site is running before you watch them
- **Website Change Monitor** to watch a changelog page for projects that do not use releases
- **Broken Link Checker** and **SEO Meta & Content Auditor** for the docs sites around those projects
- **Hacker News Brand Monitor** to catch the discussion when a release lands

# Actor input Schema

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

One per line, as owner/name or a GitHub URL, for example apify/crawlee or https://github.com/apify/crawlee.

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

Without a token GitHub allows 60 requests an hour, which is about 30 repositories. A free personal access token with no scopes raises that to 5,000. Nothing here needs any permission beyond public read.

## `maxReleasesPerRepo` (type: `integer`):

How many of the most recent releases to read for each repository.

## `includeRepoStats` (type: `boolean`):

Also fetch stars, forks, open issues and days since the last push. Costs one extra request per repository.

## `onlyNew` (type: `boolean`):

Return only releases not seen on the previous run. Turn this on for scheduled monitoring so a quiet run returns nothing.

## `includePrereleases` (type: `boolean`):

Include release candidates, betas and alphas. Off by default because they are noise for most watchers.

## `includeDrafts` (type: `boolean`):

Include unpublished draft releases, which are visible only with a token that can see them.

## `tagContains` (type: `array`):

Keep only releases whose tag contains one of these, for example v2.

## `tagExcludes` (type: `array`):

Drop releases whose tag contains one of these, for example nightly.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each GitHub API call.

## Actor input object example

```json
{
  "repositories": [
    "apify/crawlee",
    "facebook/react"
  ],
  "maxReleasesPerRepo": 10,
  "includeRepoStats": true,
  "onlyNew": false,
  "includePrereleases": false,
  "includeDrafts": false,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `releases` (type: `string`):

One row per release with its tag, changelog, author, assets and whether it is new since the last run.

## `runSummary` (type: `string`):

Counts of new releases and major bumps, plus stars, forks and days since last push for every repository watched.

# 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/crawlee",
        "facebook/react"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/github-release-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/crawlee",
        "facebook/react",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/github-release-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/eFhtZGewywKKkI04D/builds/oLJt6hsGT1a5diDSF/openapi.json