# Changelog Monitor: Competitor Release Notes & GitHub Releases (`transparent_meteorite/changelog-monitor`) Actor

Track release notes and changelogs for any product: GitHub releases, RSS and Atom changelog feeds, or plain changelog pages. Version, title, date, summary and link per entry, with a new-only mode for monitoring. No login, no key, no proxy.

- **URL**: https://apify.com/transparent_meteorite/changelog-monitor.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Developer tools, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 changelog entries

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

## Changelog Monitor: Competitor Release Notes & GitHub Releases

**Changelog monitor** for any product: pull release notes from **GitHub releases**, **RSS and Atom changelog feeds** and plain changelog pages into one flat table with version, title, date, summary and link. Switch on new-only mode and schedule it to get a feed of fresh releases. No login, no key, no proxy.

Know what your competitors and your own dependencies shipped this week. Give the Actor a list of products and it returns their latest release notes in one clean, comparable format, ready for a spreadsheet, a Slack alert, a CRM note or an AI agent.

### What is Changelog Monitor?

Changelog Monitor reads public release information and nothing else. For a GitHub repo it reads the public releases feed. For a feed URL it reads the RSS or Atom entries. For a changelog page it looks for the page's own feed link first, and if there is none it reads the version and date headings on the page. Every entry becomes one row: product, version, title, publication time, a plain-text summary of the notes, a link, and a pre-release flag. Run it from the Apify Console, the API, a schedule, n8n, Make, Zapier or an MCP client.

### Why use it

- **Three source types in one run.** GitHub repos, feed URLs and changelog pages, mixed freely in the same list.
- **Monitoring mode.** With **Only entries I have not seen** on, the first run returns the latest entries and every later run returns only what was published since.
- **Comparable rows.** The same fields for every product, so you can sort by date across all competitors.
- **Pre-release control.** Drop alpha, beta, rc, canary and nightly builds with one switch.
- **No setup.** No GitHub token, no API key, no proxy, no browser.
- **Pay for rows only.** Filter first, then pay for the rows you receive. No monthly fee.

### Output

One row per release or changelog entry:

| Field | Meaning |
|---|---|
| `source` | The product exactly as you entered it. |
| `sourceType` | `github`, `feed` or `page`. |
| `product` | Repository name, feed title or site name. |
| `version` | Version or tag, for example `v15.0.1` (empty when the entry carries none). |
| `title` | Release or entry title. |
| `publishedAt` | Publication time as ISO 8601 (empty when the source gives no date). |
| `summary` | First 500 characters of the release notes as plain text. |
| `url` | Link to the release or changelog entry. |
| `isPrerelease` | True for alpha, beta, rc, canary, nightly and preview builds. |
| `wordCount` | Words in the full release notes, a quick size signal for ranking changes. |
| `scrapedAt` | When the run read the data. |

### Sample output

```json
{
  "source": "vercel/next.js",
  "sourceType": "github",
  "product": "next.js",
  "version": "v16.4.6",
  "title": "v16.4.6",
  "publishedAt": "2026-11-09T20:27:17.000Z",
  "summary": "This release is backporting bug fixes. Core Changes ...",
  "url": "https://github.com/vercel/next.js/releases/tag/v16.4.6",
  "isPrerelease": false,
  "wordCount": 120,
  "scrapedAt": "2026-11-10T12:00:00.000Z"
}
```

### Input

| Field | What it does |
|---|---|
| `sources` | Products to track, one per line: a GitHub repo (`vercel/next.js` or the repo URL), a feed URL, or a changelog page URL. |
| `maxPerSource` | Newest entries to return per product. Default 5. |
| `onlyNew` | Return only entries not seen in an earlier run. Default off. |
| `sinceDays` | Skip entries older than this many days. 0 means no filter. |
| `includePrereleases` | Turn off to drop alpha, beta, rc, canary and nightly builds. Default on. |
| `maxItems` | Stop after this many rows in total. Default 100. |

Sample input:

```json
{
  "sources": ["vercel/next.js", "n8n-io/n8n", "https://stripe.com/blog/changelog"],
  "maxPerSource": 5,
  "onlyNew": true,
  "sinceDays": 30
}
```

### Pricing

Pay per event, no subscription. Current prices:

| Event | Price |
|---|---|
| Actor Start | $0.00005 |
| Changelog entry | $0.0028 |

Apify's free plan includes monthly platform credit that covers test runs.

A scheduled price change is on file and takes effect on its start date. The Pricing tab always shows current and upcoming prices.

Examples at the current price (one `changelog-entry` event per result; Free-plan tier):

| You pull | You pay |
|---|---|
| 100 results | $0.28 |
| 1,000 results | $2.80 |
| 10,000 results | $28.00 |

Scheduled runs stay cheap when each run only returns new records.

### What does this Actor do?

For every source it makes one to two plain HTTP requests. GitHub repos use the public releases feed (and the tags feed for repos that never published a release). Feed URLs are parsed directly. For a page URL the Actor reads the page, follows the feed it advertises if there is one, and otherwise reads headings that contain a version number or a date. Entries are converted to flat rows, filtered by your date and pre-release settings, and charged one per row. If a source cannot be read, the run continues with the others and the reason is listed in the `OUTPUT` record of the key-value store.

**Run in 30 seconds**

1. Open the Actor and press **Try for free** (a free Apify account is enough).
2. Keep the prefilled list of products, or replace it with your own, and press **Start**.
3. Open the **Output** tab. Use the table view or download CSV, Excel or JSON.

### Use cases

- Product and competitive teams: a weekly digest of what every competitor shipped, sorted by date.
- Engineering teams: watch the releases of the libraries and tools you depend on and get alerted to new versions.
- Customer success and support: know when a vendor you integrate with changed something.
- Agencies and consultants: keep client stacks current and flag upgrades worth selling.
- Investors and analysts: track shipping cadence of portfolio or target companies as a leading signal.
- AI agents: give an agent a tool that answers "what changed in product X lately?" with structured rows.

### Limits

- GitHub release feeds hold the latest 10 entries, so older history is not available through them.
- Changelog pages without a feed are read by their headings; unusual layouts may return fewer entries or none. A feed URL is more reliable when the product offers one.
- Pages that need a login or build their content only in the browser are not supported.
- `version` and `publishedAt` stay empty when the source does not provide them; the Actor does not guess.
- Up to 5,000 rows per run.

### Related Actors

- [RSS and Atom Feed Reader Monitor](https://apify.com/transparent_meteorite/rss-atom-feed-reader-monitor) reads any RSS or Atom feed into rows.
- [npm Package Download Trends](https://apify.com/transparent_meteorite/npm-package-download-trends) tracks npm package popularity.
- [PyPI Package Stats and Releases](https://apify.com/transparent_meteorite/pypi-package-stats-releases) lists Python package releases and stats.

Found a bug or need a field? Open an issue on the Issues tab with the run URL.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~changelog-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources": ["vercel/next.js", "n8n-io/n8n"], "maxPerSource": 5}'
```

The call waits up to 5 minutes. For bigger inputs, start the run with `/runs` instead and read the dataset when it finishes.

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/changelog-monitor").call(run_input={"sources": ["vercel/next.js", "n8n-io/n8n"], "maxPerSource": 5})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**MCP (AI agents):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/changelog-monitor` to Claude, Cursor or any MCP client. Your agent can then check competitor release notes, see what changed in a dependency and list new versions by calling this Actor, and it gets back the same flat rows described above.

| Tool | Setup |
|---|---|
| n8n | Add the Apify node, choose "Run Actor", set the actor to `transparent_meteorite/changelog-monitor`, paste the input JSON with `onlyNew` on, then add a "Get Dataset Items" step and send each row to Slack, email or your sheet. |
| Make and Zapier | Use the Apify app's "Run Actor" action with this actor and the input JSON, then map the dataset items. |
| Clay | Add an HTTP API column that calls the run-sync endpoint above. |
| Schedules | In Apify Console, Schedules, run it daily with `onlyNew` on for a feed of fresh releases only. |

### Search terms people use

changelog monitor, release notes tracker, competitor release notes, GitHub releases scraper, track software releases, product changelog tracker, new version alerts, release feed to JSON, SaaS changelog monitoring, what's new tracker.

### FAQ

**Which sources work best?**
GitHub repos and feed URLs are the most reliable. Many products publish a feed at `/changelog.xml`, `/feed` or `/releases.atom`; paste that URL. For other changelog pages the Actor tries the page's own feed link and then its headings.

**How does monitoring work?**
Turn on **Only entries I have not seen** and schedule the run. The first run returns the latest entries and remembers them in your account; later runs return only entries published after that.

**Do I need a GitHub token?**
No. The Actor reads the public releases feed, which has no key and does not count against the REST API limit.

**Why is `version` empty for some rows?**
Some changelogs name entries by date or feature instead of a version number. The field stays empty rather than guessed.

**Can it read private repositories?**
No. It only reads public information.

### More from DWA Open Data

Browse all our data Actors, with live prices and sample output, at [open-data-actors.pages.dev](https://open-data-actors.pages.dev).

***

**Feedback:** if this Actor was useful, or if it fell short, an honest review on the [Reviews tab](https://apify.com/transparent_meteorite/changelog-monitor/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/changelog-monitor/issues) and we usually reply within one business day.

# Changelog

This Actor's version history is a separate document: https://apify.com/transparent_meteorite/changelog-monitor/changelog.md

# Actor input Schema

## `sources` (type: `array`):

One per line: a GitHub repo (vercel/next.js or the repo URL), a changelog or release-notes page URL, or an RSS/Atom feed URL. Pages are checked for a feed first, then read for version headings.

## `maxPerSource` (type: `integer`):

Newest entries to return for each product. GitHub feeds hold the latest 10.

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

Turn this on for monitoring. The first run returns the latest entries and remembers them; every later run returns only entries published since. Memory is kept per product in your account.

## `sinceDays` (type: `integer`):

Skip entries older than this. 0 means no date filter.

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

Turn off to drop alpha, beta, rc, canary and nightly releases.

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

Stop after this many rows in total. You pay only for rows delivered.

## Actor input object example

```json
{
  "sources": [
    "vercel/next.js",
    "facebook/react",
    "microsoft/vscode",
    "n8n-io/n8n",
    "supabase/supabase",
    "stripe/stripe-node",
    "tailwindlabs/tailwindcss",
    "vitejs/vite",
    "denoland/deno",
    "grafana/grafana",
    "hashicorp/terraform",
    "prisma/prisma"
  ],
  "maxPerSource": 5,
  "onlyNew": false,
  "sinceDays": 0,
  "includePrereleases": true,
  "maxItems": 60
}
```

# Actor output Schema

## `overview` (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 = {
    "sources": [
        "vercel/next.js",
        "facebook/react",
        "microsoft/vscode",
        "n8n-io/n8n",
        "supabase/supabase",
        "stripe/stripe-node",
        "tailwindlabs/tailwindcss",
        "vitejs/vite",
        "denoland/deno",
        "grafana/grafana",
        "hashicorp/terraform",
        "prisma/prisma"
    ],
    "maxItems": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/changelog-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 = {
    "sources": [
        "vercel/next.js",
        "facebook/react",
        "microsoft/vscode",
        "n8n-io/n8n",
        "supabase/supabase",
        "stripe/stripe-node",
        "tailwindlabs/tailwindcss",
        "vitejs/vite",
        "denoland/deno",
        "grafana/grafana",
        "hashicorp/terraform",
        "prisma/prisma",
    ],
    "maxItems": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/changelog-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 '{
  "sources": [
    "vercel/next.js",
    "facebook/react",
    "microsoft/vscode",
    "n8n-io/n8n",
    "supabase/supabase",
    "stripe/stripe-node",
    "tailwindlabs/tailwindcss",
    "vitejs/vite",
    "denoland/deno",
    "grafana/grafana",
    "hashicorp/terraform",
    "prisma/prisma"
  ],
  "maxItems": 60
}' |
apify call transparent_meteorite/changelog-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/changelog-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/qT9HOaCbYU2EBxTFt/builds/LhwixZTdRvFMUMLYY/openapi.json
