# GitHub New Repo, Star-Jump & Release Alerts (API) (`fedsignals/github-repo-release-tracker`) Actor

Finds new and fast-rising GitHub repositories by topic, language and stars, and alerts on new releases of repos you watch. Official GitHub REST API, no scraping. Only new repos, releases and star jumps on scheduled runs. Optional token.

- **URL**: https://apify.com/fedsignals/github-repo-release-tracker.md
- **Developed by:** [FedSignals Data](https://apify.com/fedsignals) (community)
- **Categories:** Developer tools, AI, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 repository rows

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 New Repo, Star-Jump & Release Alerts (API)

Find **new and fast-rising GitHub repositories** by topic, language and stars, and get **new releases of the repositories you watch**, as clean JSON rows. It uses the **official GitHub REST API** (no page scraping, no login). Schedule it daily and it returns **only what's new since the last run**: new repos, new releases, and repos whose star count jumped.

Built and maintained by **FedSignals Data**.

### What it does

- **Discovers new repos**: searches GitHub for repositories created in the last N days with at least N stars, for each topic you choose (e.g. `llm`, `mcp`, `ai-agents`), optionally limited to languages (e.g. Python, Rust).
- **Tracks releases**: for every `owner/name` in `watchRepos`, returns new releases with tag, date, link and release notes.
- **Flags star jumps**: on scheduled runs, a repo you already received comes back as `star_jump` when it gained at least `starJumpThreshold` stars since the previous run.
- **Incremental by default**: `onlyNew` remembers what it already delivered (per filter set), so a daily schedule returns, and charges for, new rows only.

### Use cases

- Daily "new AI / MCP / agent repos" feed for a newsletter, Slack channel or market-research sheet
- Release alerts for the libraries and tools your product depends on
- Spotting breakout open-source projects early (VCs, devrel, competitive intelligence)
- Feeding an LLM agent or RAG pipeline with fresh repos and changelogs

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `topics` | list | `["mcp"]` | GitHub topics to search, one search per topic. Empty = all topics. |
| `languages` | list | any | GitHub language names, e.g. `Python`, `TypeScript`, `Go`. Misspellings fail before any row is charged, with a suggestion. |
| `minStars` | integer | 50 | Minimum stars. |
| `createdWithinDays` | integer | 30 | Only repos created in the last N days (1–365). |
| `watchRepos` | list | – | `owner/name` or github.com URLs to watch for new releases (up to 200). |
| `onlyNew` | boolean | true | Return only rows not delivered by an earlier run with the same filters, plus star jumps. |
| `starJumpThreshold` | integer | 100 | Stars gained since the last run that trigger a `star_jump` row (0 = off). |
| `maxItems` | integer | 100 | Max rows (and charges) per run. |
| `githubToken` | secret string | – | Optional, your own token. Raises GitHub limits (see Limits). Stored encrypted, never logged. |
| `discoverRepos` | boolean | true | Turn off to track `watchRepos` releases only. |
| `fetchLatestRelease` | boolean | true | Adds each discovered repo's latest release (one extra request per repo). |
| `releasesPerRepo` | integer | 1 | Releases per watched repo on the first run or with `onlyNew` off (1–10). |
| `includePrereleases` | boolean | false | Also return alpha/beta/rc pre-releases. |
| `includeForks` | boolean | false | Also return forks in discovery. |
| `stateKey` | string | hash of filters | Separate memory per saved task. |

Example input:

```json
{
  "topics": ["mcp", "ai-agents"],
  "languages": ["Python", "TypeScript"],
  "minStars": 100,
  "createdWithinDays": 30,
  "watchRepos": ["modelcontextprotocol/python-sdk", "ollama/ollama"],
  "onlyNew": true,
  "maxItems": 10
}
```

`maxItems` 10 caps this run at 10 rows × $0.002 = **$0.02**, plus the $0.00005 start fee ($0.02005 in total). If you cap cost with Apify's run spending limit instead, the start fee counts toward it: a $0.02 limit stops at 9 rows, so set $0.021 to get all 10.

Watch releases of projects from outside the US, e.g. Mistral AI (France) and DeepSeek (China) (tested Oct 30, 2026):

```json
{
  "discoverRepos": false,
  "watchRepos": ["mistralai/mistral-inference", "deepseek-ai/DeepSeek-V3"],
  "onlyNew": true,
  "maxItems": 50
}
```

### Output

Each dataset row is one event:

```json
{
  "eventType": "new_release",
  "repo": "modelcontextprotocol/python-sdk",
  "url": "https://github.com/modelcontextprotocol/python-sdk",
  "description": "The official Python SDK for Model Context Protocol servers and clients",
  "topics": ["mcp", "mcp-client", "mcp-server", "python"],
  "language": "Python",
  "stars": 24711,
  "starsGainedSinceLastRun": null,
  "forks": 4092,
  "openIssues": 378,
  "createdAt": "2024-09-24T21:01:35Z",
  "pushedAt": "2026-10-27T11:15:12Z",
  "homepage": "https://py.sdk.modelcontextprotocol.io/",
  "license": "MIT",
  "isFork": false,
  "latestRelease": {
    "tag": "v2.3.0",
    "name": "v2.3.0",
    "publishedAt": "2026-10-02T22:02:27Z",
    "url": "https://github.com/modelcontextprotocol/python-sdk/releases/tag/v2.3.0",
    "prerelease": false
  },
  "matchedTopic": null,
  "releaseNotes": "`pip install -U mcp`. Docs: ... (max 1,500 characters)",
  "scrapedAt": "2026-10-30T16:09:20Z"
}
```

- `eventType`: `new_repo`, `new_release` or `star_jump`
- `starsGainedSinceLastRun`: filled on incremental runs once a repo has been seen before
- `latestRelease`: for `new_release` rows this is the new release; `null` when the repo has no releases
- `releaseNotes`: the release notes on `new_release` rows, with @mentions and e-mail addresses removed; `null` on `new_repo` and `star_jump` rows
- All dates (`createdAt`, `pushedAt`, `latestRelease.publishedAt`, `scrapedAt`) are ISO 8601 in UTC (`Z`), whatever the repo owner's time zone. There are no money fields.

A `SUMMARY` record in the run's key-value store lists the searches and their total matches, rows per event type, rows skipped as already seen, watched repos with no published releases (`watchedWithoutReleases`), GitHub rate-limit state and why the run stopped (`completed`, `maxItems`, `spendingLimit`, `rateLimited`, `upstreamError`).

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Repository row (`new_repo` or `star_jump`) | $0.002 |
| Release row (`new_release`) | $0.002 |
| Actor start | $0.00005 |

That is **$2 per 1,000 rows**. A daily run that finds 20 new repos and 2 releases costs about $0.044. Already-seen rows are skipped and never charged. Invalid input fails before any row is charged (only Apify's $0.00005 start fee applies). Set a maximum cost per run in Apify and the Actor stops cleanly when it is reached.

### FAQ

**Do I need a GitHub token?** No. Without one, GitHub allows 10 searches a minute and 60 other requests an hour per IP, which covers small runs (a few topics, ~25 latest-release lookups, a handful of watched repos). For many topics, many watched repos or frequent runs, add your own token in `githubToken`; a fine-grained token with no extra permissions is enough. It is only sent to api.github.com.

**Why did I get fewer rows than GitHub shows?** With `onlyNew` on, rows already delivered by earlier runs with the same filters are skipped (see `skippedAlreadySeen` in `SUMMARY`). Turn `onlyNew` off to get every match.

**How do I get alerts in Slack or e-mail?** Save a task, schedule it daily, and add an Apify integration (Slack, e-mail, webhook, Zapier, Make) on run success.

**Does it collect personal data?** No profile data is collected: no names, e-mails, followers or contributor lists. Repository names contain the owner's public login, as on GitHub. Release notes have @mentions and e-mail addresses removed.

**What happens when GitHub's rate limit is hit?** The Actor waits up to about a minute; if the limit is longer, it returns what it has collected, says so in the status message and `SUMMARY`, and you are only charged for delivered rows.

### Other languages and regions

Works for public repositories from any country. `topics` and `languages` use GitHub's own names (topics are usually in English); repo descriptions are returned as written.

Also searched as: repositorios en tendencia de GitHub, seguimiento de versiones (ES) · repositórios em alta no GitHub, acompanhamento de versões (PT) · dépôts GitHub tendance, suivi des versions (FR) · GitHub-Trends, Release-Tracker (DE).

### Limits

- GitHub's search API returns at most 1,000 results per query; narrow the filters (more stars, fewer days, a language) for broad topics.
- Topics in one run are searched separately (GitHub combines multiple topics with AND); languages are combined with OR.
- Without a token, up to 25 latest-release lookups per run; the rest are counted in `releaseLookupsSkipped`.
- Star jumps compare against the previous run with the same filters, so they need a schedule.
- Watched repos with no published GitHub releases (only tags, or nothing yet) return no release rows; the status message names them and nothing is charged for them.
- Private repositories are not supported.

### Source and terms

Data comes from the public [GitHub REST API](https://docs.github.com/en/rest) (search, repositories and releases endpoints), used within GitHub's [rate limits](https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api). Use of the data is subject to the [GitHub Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service) (section H, API Terms) and [Acceptable Use Policies](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies); don't use it for spam or to sell personal information. This Actor is not affiliated with or endorsed by GitHub.

### Support

Questions or feature requests: open an issue on the Actor's Issues tab or e-mail fedsignals.alerts@gmail.com.

# Actor input Schema

## `topics` (type: `array`):

Returns repositories tagged with any of these GitHub topics, e.g. llm, mcp, ai-agents, rag. Each topic is one search. Empty = all topics (filtered only by stars, age and language).

## `languages` (type: `array`):

Returns only repositories whose main language is one of these GitHub language names, e.g. Python, TypeScript, Go, Rust. Empty = any language. A misspelled name fails the run before any row is charged, with a suggestion.

## `minStars` (type: `integer`):

Returns only repositories with at least this many stars. Raise it (e.g. 200) to see only breakout projects.

## `createdWithinDays` (type: `integer`):

Returns only repositories created in the last N days (1–365). Use 7–30 to find new projects.

## `watchRepos` (type: `array`):

Returns new releases of these repositories, as owner/name (e.g. langchain-ai/langchain) or a github.com URL. With 'Only new' on, each run returns only releases published since the previous run; the first run returns the current latest release. Up to 200 repositories.

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

On: returns (and charges for) only repositories and releases not delivered by an earlier run with the same filters, plus star jumps. Turn on for scheduled runs. Off: returns everything that matches, every run.

## `starJumpThreshold` (type: `integer`):

In incremental mode, a repository you already received comes back as a 'star_jump' row when it gained at least this many stars since the previous run. 0 = off.

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

Maximum rows returned (and charged) per run, across new repos, releases and star jumps.

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

Optional. Your own GitHub personal access token (a fine-grained token with no extra permissions is enough; it only reads public data). Raises GitHub's limits from 10 to 30 searches a minute and from 60 to 5,000 other requests an hour. It is stored encrypted by Apify and never logged.

## `discoverRepos` (type: `boolean`):

Turn off to only track releases of 'watchRepos'.

## `fetchLatestRelease` (type: `boolean`):

Looks up each discovered repository's latest release (one extra API request each). Without a token GitHub allows 60 such requests an hour per IP; when they run out, latestRelease is left empty and the run says so.

## `releasesPerRepo` (type: `integer`):

How many recent releases to return per watched repository on the first run, or on every run when 'Only new' is off.

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

Also return releases marked as pre-release (alpha, beta, rc).

## `includeForks` (type: `boolean`):

Also return forked repositories in discovery.

## `stateKey` (type: `string`):

Optional. Separate incremental memory per saved task. Defaults to a hash of your filters.

## Actor input object example

```json
{
  "topics": [
    "mcp"
  ],
  "minStars": 50,
  "createdWithinDays": 30,
  "watchRepos": [
    "modelcontextprotocol/python-sdk",
    "ollama/ollama"
  ],
  "onlyNew": false,
  "starJumpThreshold": 100,
  "maxItems": 10,
  "discoverRepos": true,
  "fetchLatestRelease": true,
  "releasesPerRepo": 1,
  "includePrereleases": false,
  "includeForks": false
}
```

# Actor output Schema

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

New GitHub repositories, releases and star jumps. One item per row; field definitions are in the dataset schema.

## `summary` (type: `string`):

JSON summary of the run: searches, rows per event type, skipped rows, rate-limit state and why the run stopped.

# 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 = {
    "topics": [
        "mcp"
    ],
    "watchRepos": [
        "modelcontextprotocol/python-sdk",
        "ollama/ollama"
    ],
    "onlyNew": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fedsignals/github-repo-release-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 = {
    "topics": ["mcp"],
    "watchRepos": [
        "modelcontextprotocol/python-sdk",
        "ollama/ollama",
    ],
    "onlyNew": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fedsignals/github-repo-release-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 '{
  "topics": [
    "mcp"
  ],
  "watchRepos": [
    "modelcontextprotocol/python-sdk",
    "ollama/ollama"
  ],
  "onlyNew": false,
  "maxItems": 10
}' |
apify call fedsignals/github-repo-release-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fedsignals/github-repo-release-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/6HQS92bIbWuYIEo8g/builds/465MAut07Q5f96bbG/openapi.json