# GitHub Release Intelligence (`junipr/github-release-intelligence`) Actor

Monitor public software releases and summarize breaking changes, semver jumps, and changelog signals.

- **URL**: https://apify.com/junipr/github-release-intelligence.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.50 / 1,000 target 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/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 Release Intelligence

Compare public GitHub release inventories and turn release additions, removals, note changes, asset changes, prerelease transitions, and semantic-version shifts into structured intelligence.

### What It Analyzes

- Added and removed release tags.
- Release note changes with bounded added and removed terms.
- Breaking-change and security language in release notes.
- Added or removed release assets.
- Draft and prerelease status changes.
- Major, minor, patch, and prerelease semantic-version movement.

The parser accepts GitHub Releases API arrays, common JSON wrappers, and structured release records. A public `github.com/owner/repository` URL is converted to the corresponding GitHub Releases API endpoint before retrieval.

### Input

Use `targets` for multiple repositories, or provide direct single-repository fields at the top level.

| Field | Purpose |
| --- | --- |
| `targets` | Capped previous/current repository comparisons. |
| `repo` | Repository in `owner/name` form. |
| `sourceUrl` / `urls` | Public repository or Releases API URLs. Retrieval occurs only when `fetchUrls` is true and current data is absent. |
| `previousSnapshot` / `currentSnapshot` | GitHub release JSON. |
| `previousReleases` / `currentReleases` | Structured release objects. |
| `records` | Pre-paired records containing old and new release values. |
| `includeDrafts` | Include draft releases; false by default. |
| `includeUnchanged` | Include releases whose supported fields did not change. |
| `includeReport` | Write results, summary, and Markdown report records. |
| `maxTargets` | Repository cap, from 1 through 50. |
| `maxReleasesPerTarget` | Release cap per side, from 1 through 1,000. |
| `maxItems` | Dataset row cap. |
| `maxTextBytes` | Snapshot size cap, up to 2,000,000 bytes. |

```json
{
  "repo": "acme/widgets",
  "previousReleases": [
    {
      "tag_name": "1.9.0",
      "name": "Widgets 1.9",
      "body": "Adds export filters.",
      "draft": false,
      "prerelease": false,
      "assets": [{ "name": "widgets-linux-amd64.tar.gz" }]
    }
  ],
  "currentReleases": [
    {
      "tag_name": "2.0.0",
      "name": "Widgets 2.0",
      "body": "Breaking change: legacy authentication was removed. Includes a security fix.",
      "draft": false,
      "prerelease": false,
      "assets": [
        { "name": "widgets-linux-amd64.tar.gz" },
        { "name": "widgets-linux-arm64.tar.gz" }
      ]
    }
  ],
  "maxItems": 25,
  "includeReport": true
}
```

### Dataset Rows

Each row identifies one release change or source diagnostic. Important fields include:

- `repo`, `releaseKey`, `releaseTag`, and `releaseName`.
- `changeType`, `versionDirection`, and `semverJump`.
- `breakingChangeFlag`, `securityFlag`, `draft`, and `prerelease`.
- `oldNotesHash`, `newNotesHash`, `addedNoteTerms`, and `removedNoteTerms`.
- `oldAssetNames`, `newAssetNames`, `oldArtifactCount`, and `newArtifactCount`.
- Publication times, release URLs, severity, score, checked time, and recommendation.
- `diagnosticCode` and `sourceError` for blocked retrieval or an empty release parse.

Change types are `release-added`, `release-removed`, `release-notes-changed`, `assets-changed`, `status-changed`, `details-changed`, and `unchanged`.

### Stored Artifacts

- Dataset: one row per release change, unchanged release, or diagnostic that passes configured filters and caps.
- `GITHUB_RELEASE_INTELLIGENCE_RESULTS.json`: emitted rows.
- `GITHUB_RELEASE_INTELLIGENCE_SUMMARY.json`: release, breaking-change, security, diagnostic, and charge-limit counts.
- `GITHUB_RELEASE_INTELLIGENCE_REPORT.md`: readable release change digest.

### Usage Charges

The actor uses pay per event. Platform usage is included in these event prices.

| Event | Price | When charged |
| --- | ---: | --- |
| `actor-start` | $0.02000 | Once before paid work starts. |
| `target-checked` | $0.00650 | Before each repository target is processed. |
| `snapshot-compared` | $0.00650 | Before a successfully prepared release pair is compared. |
| `change-detected` | $0.01300 | Before each changed release row is emitted. |
| `digest-generated` | $0.05000 | Before JSON result and summary records are written. |
| `executive-report-generated` | $0.10000 | Before the Markdown report is written. |

If Apify reports that a charge was limited or only partly accepted, the actor stops before the corresponding paid output. Set `includeReport` to false when KVS report artifacts are not needed.

### Public Tasks

Five capped task inputs cover major releases, breaking or security notes, asset changes, prerelease status, and a release digest. Each task uses concrete GitHub release objects and bounded output.

### Retrieval Safety

- Only public `http` and `https` URLs are accepted.
- Credentials in URLs and redirects are rejected.
- Loopback, link-local, and private network destinations are blocked unless `allowPrivateUrls` is explicitly enabled for controlled testing.
- Response length, retained snapshot bytes, target count, release count, and request duration are bounded.
- Fetch failures and empty parses produce explicit diagnostic rows. Missing tags are not replaced with fictional versions.

### Limitations

- The actor uses public GitHub endpoints and does not accept access tokens, so GitHub rate limits apply.
- Release notes are classified by explicit terms; the actor does not claim semantic understanding beyond the reported flags and term differences.
- Scheduling and baseline retention are managed by the caller. Pass prior Releases API data into each comparison.
- Commit history, pull requests, package registries, and private repositories are outside this actor's scope.

# Actor input Schema

## `targets` (type: `array`):

Capped previous/current comparisons.

## `sourceId` (type: `string`):

Stable identifier for a direct single-target comparison.

## `title` (type: `string`):

Human-readable direct target name.

## `sourceUrl` (type: `string`):

Public current-state URL fetched only when enabled.

## `urls` (type: `array`):

Public URLs converted into capped fetch targets.

## `previousSnapshot` (type: `string`):

Previous JSON, HTML, or text snapshot.

## `currentSnapshot` (type: `string`):

Current JSON, HTML, or text snapshot.

## `records` (type: `array`):

Records that already contain previous/current comparison fields.

## `fetchUrls` (type: `boolean`):

Fetch sourceUrl only when the current snapshot is omitted.

## `fetchTimeoutMs` (type: `integer`):

Per-request timeout in milliseconds.

## `allowPrivateUrls` (type: `boolean`):

Permit private or loopback hosts only for controlled testing.

## `maxTargets` (type: `integer`):

Maximum comparisons in one run.

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

Maximum billable dataset rows emitted by one run.

## `maxReleasesPerTarget` (type: `integer`):

Maximum records read from each side of one target.

## `maxTextBytes` (type: `integer`):

Maximum bytes retained for each snapshot.

## `includeUnchanged` (type: `boolean`):

Include records with no comparable changes.

## `includeReport` (type: `boolean`):

Write results, summary, and Markdown report artifacts.

## `dryRun` (type: `boolean`):

Validate input without paid output.

## `debug` (type: `boolean`):

Enable debug logging.

## `repo` (type: `string`):

Repository in owner/name form for a direct comparison.

## `previousReleases` (type: `array`):

Previous GitHub release objects.

## `currentReleases` (type: `array`):

Current GitHub release objects.

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

Include GitHub draft releases in comparisons.

## Actor input object example

```json
{
  "targets": [],
  "sourceId": "",
  "title": "",
  "sourceUrl": "",
  "urls": [],
  "previousSnapshot": "",
  "currentSnapshot": "",
  "records": [],
  "fetchUrls": false,
  "fetchTimeoutMs": 10000,
  "allowPrivateUrls": false,
  "maxTargets": 1,
  "maxItems": 100,
  "maxReleasesPerTarget": 100,
  "maxTextBytes": 250000,
  "includeUnchanged": false,
  "includeReport": true,
  "dryRun": false,
  "debug": false,
  "repo": "",
  "previousReleases": [],
  "currentReleases": [],
  "includeDrafts": false
}
```

# Actor output Schema

## `results` (type: `string`):

Compare GitHub Releases API data, notes, assets, and semantic versions.

## `artifact1` (type: `string`):

GITHUB\_RELEASE\_INTELLIGENCE\_RESULTS.json

## `artifact2` (type: `string`):

GITHUB\_RELEASE\_INTELLIGENCE\_SUMMARY.json

## `artifact3` (type: `string`):

GITHUB\_RELEASE\_INTELLIGENCE\_REPORT.md

# 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("junipr/github-release-intelligence").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("junipr/github-release-intelligence").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 '{}' |
apify call junipr/github-release-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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