# API Breaking-Change Impact Radar (`travelmonitorlab/api-breaking-change-radar`) Actor

Monitors public APIs for breaking changes, deprecations and sunsets. Diffs OpenAPI specs with oasdiff, classifies GitHub releases and RSS changelogs into audit-ready impact events. AI-agent ready, API + MCP ready.

- **URL**: https://apify.com/travelmonitorlab/api-breaking-change-radar.md
- **Developed by:** [Travel Monitor Lab](https://apify.com/travelmonitorlab) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## API Breaking-Change Impact Radar

Monitor any public API for **breaking changes, deprecations and sunsets** — before they break your production. The actor diffs OpenAPI specs with [oasdiff](https://github.com/oasdiff/oasdiff) (the reference engine for spec-level breaking-change detection) and classifies GitHub releases / RSS changelog entries into audit-ready impact events.

### Use this tool when...

- You integrate third-party APIs (Stripe, GitHub, Twilio, OpenAI, Discord, Slack…) and need to know **the day** a breaking change or deprecation appears — not the day your clients call you.
- You run a platform or agency and must route each change to the right **owner** with evidence and a recommended action.
- An AI agent needs a structured, MCP/API-consumable feed of API impact events (each event carries `evidence_url`, `severity`, `recommended_action`).

### How it works

1. **`openapi` sources** (most precise): the spec is fetched and hashed. On change, the previous and new specs are diffed with `oasdiff breaking --format json`. Every entry is normalized: path, operation, severity (`critical` = breaking, `warning` = deprecation, `info` = additive).
2. **`github-releases` sources**: new releases since the last run are classified by rule tiers (breaking / deprecation / security / additive keywords).
3. **`rss` sources**: new feed entries classified the same way.

State lives in the run's key-value store, so the first run records a **baseline** and detection starts on the next change. Schedule the actor (daily/weekly) for continuous radar coverage.

### Input

| Field | Type | Description |
|---|---|---|
| `apis` | array | **Required.** APIs to monitor: `{name, type, url, owner?}`. `type` = `openapi` (raw spec URL), `github-releases` (`owner/repo` or repo URL), `rss` (feed URL). |
| `webhookUrl` | string | Optional. POST endpoint receiving a JSON summary at the end of each run (Slack/Discord/Teams compatible `text` field included). |
| `dryRun` | boolean | Default `true`. When true, **no pay-per-event fee is charged** — full detection runs, billing is simulated. Set to `false` in production. |
| `maxApis` | integer | Safety cap per run (default 25). |

#### Example input

```json
{
  "apis": [
    {"name": "github", "type": "openapi", "url": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json", "owner": "platform-team"},
    {"name": "stripe", "type": "openapi", "url": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json", "owner": "payments"},
    {"name": "my-provider", "type": "github-releases", "url": "owner/repo"}
  ],
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ",
  "dryRun": false
}
```

### Output

One dataset item per detected change:

| Field | Description |
|---|---|
| `api` / `owner` | API name and the responsible person/team you declared |
| `detected_at` | ISO-8601 detection timestamp |
| `change_class` | `breaking` · `deprecation` · `security` · `additive` · `baseline` · `monitor-error` |
| `severity` | `critical` · `warning` · `info` |
| `title` / `summary` | What changed, human-readable |
| `path` / `method` | Affected endpoint (openapi sources) |
| `evidence_url` | Public proof of the change — auditable |
| `detector` | Engine that caught it (`oasdiff`, `rule:<tier>`, `baseline`) |
| `recommended_action` | Concrete next step |

A run-level `SUMMARY` record (counts by class + top critical changes) is stored in the output key-value store.

### Pricing (pay-per-event, transparent)

| Event | What you pay for |
|---|---|
| `run-started` | Flat per run — covers fixed compute so you never pay per tiny check |
| `api-checked` | Per API monitored per run |
| `breaking-change-detected` | Per breaking/deprecation event found — the unit of value |
| `critical-alert` | Per critical-severity event with evidence |

Compute is a few seconds of CPU per API (no browser, no proxy), so runs cost cents. **Set `dryRun: true` to test your configuration for free.**

### Scheduling

Use Apify Schedules (`daily at 06:00` recommended) so baselines stay fresh and every provider change is caught within 24h.

### Limits & honesty

- `openapi` detection is exact only when the provider maintains a public spec. Without a spec, classification is keyword-based and can miss or over-flag entries — treat `warning` items as review candidates.
- GitHub release fetching uses the unauthenticated public API (60 req/h shared). For heavy multi-repo setups, run less frequently.
- The actor never guarantees exhaustive coverage: it is a radar, not an audit. Verify critical items against the provider's official changelog before acting.

AI-agent ready · API + MCP ready · Built on oasdiff.

# Actor input Schema

## `apis` (type: `array`):

List of APIs to watch. For type 'openapi', url must point to a raw OpenAPI spec (JSON or YAML). For type 'github-releases', url must be 'owner/repo' or a GitHub repo URL. For type 'rss', url must be an RSS/Atom changelog feed.

## `webhookUrl` (type: `string`):

POST endpoint called at the end of each run with a JSON summary (counts by class + top critical changes). Slack/Discord/Teams incoming-webhook compatible payload is included.

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

When true, the actor performs the full detection but does NOT charge any pay-per-event fee. Use for testing your configuration.

## `maxApis` (type: `integer`):

Safety cap on the number of APIs processed in one run.

## Actor input object example

```json
{
  "apis": [
    {
      "name": "github",
      "type": "openapi",
      "url": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json"
    },
    {
      "name": "stripe",
      "type": "openapi",
      "url": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json"
    }
  ],
  "dryRun": true,
  "maxApis": 25
}
```

# Actor output Schema

## `changeEvents` (type: `string`):

One record per detected API change: api, owner, detected\_at, change\_class, severity, title, path, method, evidence\_url, detector, summary, recommended\_action.

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

Counts by change class, top critical changes, APIs checked/failed.

# 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 = {
    "apis": [
        {
            "name": "github",
            "type": "openapi",
            "url": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json"
        },
        {
            "name": "stripe",
            "type": "openapi",
            "url": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("travelmonitorlab/api-breaking-change-radar").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 = { "apis": [
        {
            "name": "github",
            "type": "openapi",
            "url": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json",
        },
        {
            "name": "stripe",
            "type": "openapi",
            "url": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("travelmonitorlab/api-breaking-change-radar").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 '{
  "apis": [
    {
      "name": "github",
      "type": "openapi",
      "url": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json"
    },
    {
      "name": "stripe",
      "type": "openapi",
      "url": "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json"
    }
  ]
}' |
apify call travelmonitorlab/api-breaking-change-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,travelmonitorlab/api-breaking-change-radar"
        }
    }
}

```

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/YzyUbZgePKckx2XqG/builds/Vx2jeTXjN2Fdg7bKv/openapi.json