# Claude Code Changelog Watcher (`ianymu/claude-code-changelog-watcher`) Actor

Watch anthropics/claude-code releases + commits + CHANGELOG.md for new features, breaking changes, and bug fixes. Emits a structured 'what's new' feed with topic tags (hooks / skills / agents / slash commands) so Claude Code power users can be first to learn about new capabilities.

- **URL**: https://apify.com/ianymu/claude-code-changelog-watcher.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does Claude Code Changelog Watcher do?

**Claude Code Changelog Watcher** turns the `anthropics/claude-code` repo into a structured "what's new" feed for Claude Code power users. It pulls every [GitHub release](https://github.com/anthropics/claude-code/releases), parses the release body and the raw `CHANGELOG.md` file, classifies each line (`feat` / `fix` / `break` / `docs` / `chore` / `perf` / `refactor`), tags mentions of **hooks, skills, agents, slash commands, MCP, plugins, worktrees**, and emits one JSON row per release. Run it once or [schedule it](https://docs.apify.com/platform/schedules) to be the first person on your team to learn about new Claude Code capabilities — with full Apify API access, retries, and monitoring.

Built by [Ian Mu](https://github.com/ianymu) as part of a 100-Apify-Actor portfolio. Companion repo: [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop) — a Stop-hook that enforces "verify before stop" on Claude Code runs.

### Why use Claude Code Changelog Watcher?

- **Power users** want to know the second a new hook type, slash command, or skill API ships — this Actor flags those topics automatically.
- **Tool builders** integrating with Claude Code need a structured signal of breaking changes; the `breakingChanges` count + `isBreaking` flag on each entry makes that trivial.
- **Internal platform teams** can pipe this into Slack/Discord/email and stop reading raw changelogs.
- **Researchers / journalists** can produce "what shipped this quarter" reports without scraping markdown by hand.
- **Compared to a GitHub watch subscription**, you get classification, topic tags, filterable date ranges, and dataset exports (CSV, Excel, JSON, HTML).

### How to use Claude Code Changelog Watcher

1. Click **Try for free** to open the Actor.
2. Optionally set **Since** to an ISO date (`2026-05-01`) or version tag (`v1.40.0`).
3. Optionally narrow **Filter by entry types** — most users keep `feat`, `fix`, `break`, `docs`.
4. (Optional) Paste a GitHub token in **GitHub token** to raise the 60 req/h anonymous limit. The Actor still works without one.
5. Click **Start**. Most runs finish in seconds.
6. Open the **Dataset** tab and download / call via [Apify API](https://docs.apify.com/api/v2#/reference/datasets).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `since` | string | 30 days ago | ISO date (`2026-05-01`) or version tag (`v1.40.0`). |
| `categoryFilter` | array of strings | `["feat","fix","break","docs"]` | Only emit releases containing at least one entry of these types. |
| `maxResults` | integer | `30` | Max releases to emit. |
| `includeChangelogFile` | boolean | `true` | Also parse raw `CHANGELOG.md` to catch versions not yet tagged. |
| `githubToken` | string (secret) | none | Raises GitHub API rate limit. |

Example input:

```json
{
  "since": "2026-04-01",
  "categoryFilter": ["feat", "break"],
  "maxResults": 20,
  "includeChangelogFile": true
}
````

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "version": "v1.42.0",
  "publishedAt": "2026-05-18T17:30:00.000Z",
  "url": "https://github.com/anthropics/claude-code/releases/tag/v1.42.0",
  "entries": [
    {
      "type": "feat",
      "text": "Added Stop hooks for verification before exit",
      "topics": ["hooks", "verification"],
      "isBreaking": false
    },
    {
      "type": "break",
      "text": "Slash command discovery now requires a manifest file",
      "topics": ["slash-commands"],
      "isBreaking": true
    }
  ],
  "totalEntries": 12,
  "breakingChanges": 2
}
```

### Data table

| Field | Type | Notes |
|---|---|---|
| `version` | string | e.g. `v1.42.0`. |
| `publishedAt` | ISO string | From GitHub release publish time. |
| `url` | string | GitHub release URL. |
| `entries` | array of objects | One per changelog bullet — see below. |
| `entries[].type` | string | `feat`, `fix`, `break`, `docs`, `chore`, `perf`, `refactor`, `other`. |
| `entries[].text` | string | Original bullet text. |
| `entries[].topics` | array of strings | `hooks`, `skills`, `agents`, `slash-commands`, `mcp`, `plugins`, `worktrees`, etc. |
| `entries[].isBreaking` | boolean | True if `break` type or text contains "breaking". |
| `totalEntries` | integer | Count of bullets in this release. |
| `breakingChanges` | integer | Count of breaking entries. |

### Pricing / Cost estimation

This Actor uses the **GitHub REST API + a raw markdown fetch** — no headless browser, no proxy. Typical runs touch fewer than 5 HTTP requests and finish in seconds, using **<0.01 compute units** per run. A daily schedule for a full year typically costs under a dollar of Apify platform credit. With an anonymous token you may hit the 60 req/h limit on burst usage — provide `githubToken` to remove that constraint.

### Tips or Advanced options

- Pair with [anthropic-blog-tracker](https://apify.com/ianymu/anthropic-blog-tracker) for a complete Anthropic announcement feed (blog posts + Claude Code releases).
- Filter `categoryFilter: ["break"]` and schedule daily — get pinged only when something might break your workflow.
- Filter by topic downstream: in your Apify Dataset query, post-filter `entries[].topics CONTAINS "hooks"` to get a hook-specific feed.
- If you maintain a Claude Code plugin, run this with `since=<your-last-release>` to spot newly supported APIs.

### FAQ, disclaimers, and support

- **Is this affiliated with Anthropic?** No. This Actor uses the public GitHub API and raw file fetch.
- **Why are some releases missing entries?** The Actor parses bullet lists. If a release body is a paragraph blob instead of bullets, `entries` may be empty and the release is skipped.
- **Does it work without a token?** Yes, but GitHub limits anonymous requests to 60/hour. Provide `githubToken` if you schedule frequent runs.
- **Bug or feature request?** Open an issue on the GitHub repo, or contact Ian Mu via [github.com/ianymu](https://github.com/ianymu). Custom variations (e.g. push to Postgres, classify with an LLM, send Slack diff) are available.
- **Related**: see [anthropic-blog-tracker](https://apify.com/ianymu/anthropic-blog-tracker) and [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop).

# Actor input Schema

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

Either an ISO date (e.g. 2026-05-01) or a version tag (e.g. v1.40.0). Releases older than this are skipped. Defaults to 30 days ago.

## `categoryFilter` (type: `array`):

Only emit releases that contain at least one entry of these types. Allowed: feat, fix, break, docs, chore, perf, refactor, other. Empty = no filter.

## `maxResults` (type: `integer`):

Maximum number of releases to emit.

## `includeChangelogFile` (type: `boolean`):

If true, also fetch the raw CHANGELOG.md and merge entries that aren't yet tagged as releases.

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

If provided, used to raise GitHub API rate limits. Anonymous requests work for small runs but may hit 60 req/h.

## Actor input object example

```json
{
  "categoryFilter": [
    "feat",
    "fix",
    "break",
    "docs"
  ],
  "maxResults": 30,
  "includeChangelogFile": true
}
```

# 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("ianymu/claude-code-changelog-watcher").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("ianymu/claude-code-changelog-watcher").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 ianymu/claude-code-changelog-watcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/claude-code-changelog-watcher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Claude Code Changelog Watcher",
        "description": "Watch anthropics/claude-code releases + commits + CHANGELOG.md for new features, breaking changes, and bug fixes. Emits a structured 'what's new' feed with topic tags (hooks / skills / agents / slash commands) so Claude Code power users can be first to learn about new capabilities.",
        "version": "0.0",
        "x-build-id": "OyvpnwdC0BiMYZvMT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~claude-code-changelog-watcher/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-claude-code-changelog-watcher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~claude-code-changelog-watcher/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-claude-code-changelog-watcher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~claude-code-changelog-watcher/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-claude-code-changelog-watcher",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "since": {
                        "title": "Since date or version tag",
                        "type": "string",
                        "description": "Either an ISO date (e.g. 2026-05-01) or a version tag (e.g. v1.40.0). Releases older than this are skipped. Defaults to 30 days ago."
                    },
                    "categoryFilter": {
                        "title": "Filter by entry types",
                        "type": "array",
                        "description": "Only emit releases that contain at least one entry of these types. Allowed: feat, fix, break, docs, chore, perf, refactor, other. Empty = no filter.",
                        "default": [
                            "feat",
                            "fix",
                            "break",
                            "docs"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max releases",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of releases to emit.",
                        "default": 30
                    },
                    "includeChangelogFile": {
                        "title": "Also parse CHANGELOG.md",
                        "type": "boolean",
                        "description": "If true, also fetch the raw CHANGELOG.md and merge entries that aren't yet tagged as releases.",
                        "default": true
                    },
                    "githubToken": {
                        "title": "GitHub token (optional)",
                        "type": "string",
                        "description": "If provided, used to raise GitHub API rate limits. Anonymous requests work for small runs but may hit 60 req/h."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```