# GitHub Release Watch — new releases only (`maxeee/github-release-watch`) Actor

Watch GitHub repos for new releases via the official API. Dataset has only new tags, not a full dump. No scraping.

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

## Pricing

from $150.00 / 1,000 new releases

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?

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 Watch — new releases only

Watch **github releases** for a list of `owner/repo` targets via the official REST API `GET /repos/{owner}/{repo}/releases`. The dataset contains **only new releases** (not a full dump). No HTML scrape, no emails.

Category: Developer tools · Tags: github, releases, monitor, watch, api

generatedBy: Grok Bot BUILDER, version 0.1

### Watchlist of owner/repo

Paste a watchlist of repositories (`vercel/next.js`, or `https://github.com/owner/repo`). Each poll fetches the latest page of official GitHub releases (not a crawl). First sight of a repo seeds a baseline in KV so you do not get a historical dump; later runs emit only releases that were not seen before.

### Diff since last run

Seen GitHub release ids persist in the default key-value store under `SEEN_RELEASE_IDS`. Schedule the Actor: each run diffs against the last poll and emits only new rows as `{ owner, repo, tagName, name, url, publishedAt, isPrerelease }`. Empty poll (API ok, 0 new) = `watch_run` only. Repos with no releases yet still count as a successful check and are baselined, so the first future tag is emitted.

### Agent poll

Return only new GitHub releases since last run. Call from an agent on a schedule. `githubToken` is optional (public repos work unauthenticated; a token raises the rate limit and can see private repos you can access). Default `dryRun` is false so PPE charges; set `dryRun` true to skip `Actor.charge` while still calling the official API. Personal emails in `repos` are dropped and never sent to GitHub.

#### Example input

```json
{
  "repos": ["vercel/next.js"],
  "costCapUsd": 1.0
}
```

#### Input

Required:

- `repos`: string array of `owner/repo` (or github.com URLs). Max 20. Example: `vercel/next.js`.

Optional: `githubToken` (secret), `costCapUsd` (default 1.0), `dryRun` (default false), `seenStoreKey`.

#### Output (dataset)

Only **new** GitHub releases:

- `owner`, `repo`, `tagName`, `name`, `url`, `publishedAt`, `isPrerelease`

Run summary is stored as key-value `OUTPUT`. Dedup state: `SEEN_RELEASE_IDS`.

#### Pricing (PPE)

- Event `watch_run`: **$0.05** once per poll if the official API succeeded for at least one repo (including empty)
- Event `new_release`: **$0.15** per newly seen release pushed
- Empty poll = watch\_run only. Do not charge `new_release` on empty or on baseline seed.
- **No charge** if 0 API checks succeeded (every repo failed or none ran)
- `dryRun` true skips `Actor.charge` (default false)
- `costCapUsd` default 1.0 (hard max 5.0)

### FAQ

**Does this scrape GitHub HTML?** No. Official `GET /repos/{owner}/{repo}/releases` via `fetch` only.

**Do I need a GitHub token?** No for public repos. Token is optional. Unauthenticated quota is 60 requests/hour. Pass `githubToken` for private repos or higher limits. Tokens are never logged.

**What should an agent ask for?** Return only new GitHub releases since last run.

**Why was the first run empty?** The first successful poll of a repo seeds a baseline (no `new_release` charge) so you are not billed for history. The next new tag is the first dataset row.

**Are emails allowed as input?** No. Personal emails are skipped before any API call and are never charged.

**Are drafts included?** No. Drafts are skipped. Prereleases are included with `isPrerelease: true`.

**What if every repo 404s?** The run completes with errors in `OUTPUT`, an empty dataset, and **no PPE charge**.

generatedBy: Grok Bot BUILDER, version 0.1

# Actor input Schema

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

Required. owner/repo strings or github.com URLs (e.g. vercel/next.js). Max 20. Personal emails are skipped and never sent to GitHub.

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

Optional. Fine-grained or classic token for higher rate limits and private repos. Public repos work without a token (unauthenticated 60 req/h). Never logged.

## `costCapUsd` (type: `number`):

Stop charging before exceeding. watch\_run = $0.05 per successful poll; new\_release = $0.15 each. Empty poll = watch\_run only. No charge if 0 repos succeeded.

## `seenStoreKey` (type: `string`):

KV key for previously seen GitHub release ids (diff since last run).

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

When true, skips Actor.charge — still calls GET /repos/{owner}/{repo}/releases and writes dataset/KV. Default false.

## Actor input object example

```json
{
  "repos": [
    "vercel/next.js"
  ],
  "costCapUsd": 1,
  "seenStoreKey": "SEEN_RELEASE_IDS",
  "dryRun": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Only newly seen GitHub releases: owner, repo, tagName, name, url, publishedAt, isPrerelease. Not a full dump.

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

No description

## `seenReleaseIds` (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 = {
    "repos": [
        "vercel/next.js"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maxeee/github-release-watch").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": ["vercel/next.js"] }

# Run the Actor and wait for it to finish
run = client.actor("maxeee/github-release-watch").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 '{
  "repos": [
    "vercel/next.js"
  ]
}' |
apify call maxeee/github-release-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maxeee/github-release-watch"
        }
    }
}

```

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/KXmRA9AODK9RUWmXy/builds/aFo0Mid03FSCH7mOJ/openapi.json