# Open Source Releases Tracker (`gochujang/open-source-releases-tracker`) Actor

Track GitHub releases and changelogs for open source projects: version number, release notes, publish date, assets, prerelease status, and download counts. Monitor multiple repos for new releases. Uses GitHub API. Optional token for higher rate limits.

- **URL**: https://apify.com/gochujang/open-source-releases-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

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

## Open Source Releases Tracker

Monitor GitHub releases across multiple open source repositories in one run. Get version tags, changelogs, publish dates, asset download counts, and prerelease status — all structured and ready for downstream automation.

### What does Open Source Releases Tracker do?

Open Source Releases Tracker calls the **GitHub Releases API** for each repository you specify and returns structured data per release: tag name, release notes (changelog), publish date, author, asset list metadata, total download counts, and whether the release is a prerelease or draft. Try it on any public GitHub repo — no token required for basic usage.

Runs on the Apify platform: schedule it to run daily, stream results to Slack or Notion via integrations, or trigger it from your CI pipeline via API.

### Why use Open Source Releases Tracker?

- **Dependency monitoring** — Watch upstream libraries for breaking-change releases before they affect your project.
- **Competitive intelligence** — Track release cadence and changelog content of competing tools.
- **Release automation** — Trigger downstream actions (notifications, changelog summaries, deploy pipelines) when a new version lands.
- **Security auditing** — Detect patch releases that address CVEs across your dependency graph.
- **Research & analytics** — Aggregate download counts and release frequency across the open source ecosystem.

### How to use Open Source Releases Tracker

1. Open the **Input** tab in Apify Console.
2. Add one or more repositories in `owner/repo` format (e.g. `microsoft/vscode`, `facebook/react`).
3. Set **Max Releases Per Repo** (default: 5). Increase to fetch historical releases.
4. Optionally set a **Since Date** (ISO format) to restrict results to recent releases only.
5. Toggle **Include Prereleases** if you want alpha/beta/RC versions.
6. Optionally provide a **GitHub Token** to raise your rate limit from 60 to 5000 requests/hour.
7. Click **Start** and view results in the **Output** tab.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `repositories` | string\[] | — | **Required.** List of `owner/repo` strings |
| `maxReleasesPerRepo` | integer | 5 | Max releases per repo (1–100) |
| `includePrerelease` | boolean | false | Include alpha, beta, RC versions |
| `since` | string | — | ISO date filter, e.g. `2024-01-01` |
| `githubToken` | string | — | GitHub PAT for higher rate limits |

Example input:

```json
{
  "repositories": ["microsoft/vscode", "facebook/react", "tiangolo/fastapi"],
  "maxReleasesPerRepo": 3,
  "includePrerelease": false,
  "since": "2024-01-01"
}
```

### Output

Each release is saved as a separate dataset item. You can download the dataset in JSON, CSV, HTML, or Excel format.

Example output item:

```json
{
  "repo": "microsoft/vscode",
  "owner": "microsoft",
  "repo_name": "vscode",
  "tag_name": "1.89.0",
  "release_name": "April 2024",
  "published_at": "2024-05-02T19:00:00Z",
  "is_prerelease": false,
  "is_draft": false,
  "branch_or_tag": "main",
  "author": "bpasero",
  "changelog": "## Accessibility improvements\n\n...",
  "assets_count": 12,
  "total_downloads": 1820345,
  "release_url": "https://github.com/microsoft/vscode/releases/tag/1.89.0",
  "fetched_at": "2024-09-01T10:00:00+00:00"
}
```

### Data table

| Field | Description |
|-------|-------------|
| `repo` | Full `owner/repo` string |
| `owner` | Repository owner (user or org) |
| `repo_name` | Repository name |
| `tag_name` | Git tag, e.g. `v1.2.3` |
| `release_name` | Human-readable release title |
| `published_at` | ISO 8601 publish timestamp |
| `is_prerelease` | `true` for alpha/beta/RC |
| `is_draft` | `true` for draft releases (skipped by default) |
| `branch_or_tag` | Target branch or commit SHA |
| `author` | GitHub login of release author |
| `changelog` | Release notes body (first 2000 chars) |
| `assets_count` | Number of binary assets attached |
| `total_downloads` | Sum of all asset download counts |
| `release_url` | Direct link to the GitHub release page |
| `fetched_at` | Timestamp when this data was collected |

### Pricing / Cost estimation

This Actor uses **Pay-Per-Event** billing at **$0.002 per repository checked** (regardless of how many releases are returned).

- 10 repositories → ~$0.02
- 100 repositories → ~$0.20
- 1,000 repositories → ~$2.00

Apify's free tier includes $5 of platform credit monthly, so small monitoring jobs (up to ~2,500 repos/month) run at no cost.

### Tips

- **Rate limits**: Without a GitHub token the API allows 60 requests/hour. For large repo lists, provide a Personal Access Token (PAT) to raise the limit to 5,000/hour. Generate one at [github.com/settings/tokens](https://github.com/settings/tokens) — no special scopes needed for public repos.
- **Historical data**: Set `maxReleasesPerRepo` to `100` and omit `since` to pull the full release history.
- **Scheduling**: Schedule the Actor to run daily with a `since` date set dynamically — use Apify's [scheduled tasks](https://docs.apify.com/schedules) to monitor for new releases automatically.
- **Concurrency**: The Actor fetches up to 5 repositories in parallel, respecting GitHub's rate limit headers automatically.

### FAQ, disclaimers, and support

**Is this legal?** Yes. The GitHub Releases API is a public, officially documented endpoint. This Actor only reads publicly available release data and respects GitHub's rate limits.

**What about private repositories?** Private repos require a token with `repo` scope. Without a valid token, private repos will return a 403 and be skipped.

**Known limitations**: GitHub's API returns at most 100 releases per request. Repos with more than 100 releases will be capped at `maxReleasesPerRepo` (max 100).

For bugs or feature requests, open an issue in the **Issues** tab. Custom integrations or bulk monitoring solutions are available on request.

***

### Related actors

- [GitHub Repo Stats](https://apify.com/gochujang/github-repo-stats) — Star growth, forks, and contributors for the same repos you track releases on
- [GitHub CI Monitor](https://apify.com/gochujang/github-ci-monitor) — CI/CD deployment frequency and failure rates for repositories you monitor releases on
- [npm Package Trends](https://apify.com/gochujang/npm-package-trends) — npm download spikes that often follow major open source releases

### Feedback

If this actor helps your open source monitoring, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/open-source-releases-tracker#reviews)

***

**Keywords:** open source releases tracker, GitHub release monitor, software version tracker, GitHub tags API, open source changelog, new release detector, dependency update tracker, software release calendar, GitHub releases scraper, version bump monitor, library release alerts, open source project updates, GitHub API releases, patch release tracker, security patch monitor

# Actor input Schema

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

List of repos as owner/repo (e.g. 'microsoft/vscode', 'facebook/react')

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

Maximum number of releases to fetch per repository

## `includePrerelease` (type: `boolean`):

Include alpha, beta, and release candidate versions

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

Only return releases published after this ISO date (e.g. 2024-01-01)

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

Personal access token for higher rate limits (5000 req/h vs 60 req/h)

## Actor input object example

```json
{
  "maxReleasesPerRepo": 5,
  "includePrerelease": false
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/open-source-releases-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/open-source-releases-tracker").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 '{}' |
apify call gochujang/open-source-releases-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/open-source-releases-tracker"
        }
    }
}
```

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/yCYddP8qjGDAnamwH/builds/otE65eQgBTfc3Y4Zt/openapi.json