MCP Registry Tracker

Tracks the official Model Context Protocol (MCP) registry (registry.modelcontextprotocol.io) and tells you what changed since your last run: new MCP servers, updated versions, deprecations, and deletions — with canonical dedup, optional GitHub health signals (stars, forks, last push, archived), and trending ranks based on your own run history.

Quickstart

1. Run the Actor with default input (mode: "delta"). The first run quietly seeds change-tracking state (~2 min, run-start fee only, no rows) — set firstRunFullSnapshot: true if you want the full registry delivered immediately instead.
2. Schedule it (e.g. daily). Every later run emits only servers that are new / updated / deprecated / deleted since your previous run.
3. Read results from the default dataset (JSON/CSV/Excel via the Apify API or console).

Honest framing: what you are paying for

The raw registry API is free and public — anyone can call it. This Actor sells the layer the free API cannot give you:

• Persistent change tracking — run-over-run deltaType (new / updated / deprecated / deleted) kept in a named key-value store under your account (mcp-registry-state).
• Deletion detection — servers that vanish from the registry between complete snapshots are emitted as deltaType: "deleted" rows.
• Canonical dedup — registry entries pointing at the same repository (including renames) are collapsed; monorepo subfolders are kept distinct; prior names land in aliases.
• GitHub enrichment — stars, forks, last push, archived flag for servers with GitHub repos.
• Trending — starsDelta and trendingRank computed against your previous run's state.

If you just want a one-off dump of the registry, the free API (or mode: "snapshot" here) will do it; the recurring value is the delta feed.

Modes and input recipes

Daily delta feed (recommended)

{ "mode": "delta", "enrichGithub": true, "githubToken": "ghp_yourtoken" }

First run: seeds state silently (run-start fee only, ~2 min, no rows emitted). Set firstRunFullSnapshot: true if you want the first run to deliver the full registry (~25,000 rows, billed at the snapshot rate — use the default 3600s timeout). Every later run: only changed servers, typically tens of rows per day.

Weekly full snapshot (also reconciles deletions)

{ "mode": "snapshot" }

A complete, deduped export of the current registry (~25,000+ rows — see pricing below). When you have a previous complete snapshot in state, vanished servers are appended as deltaType: "deleted" rows.

Search-filtered watch

{ "mode": "delta", "search": "postgres" }

Uses the registry's search parameter. Each distinct search term keeps its own delta timeline, so a "postgres" watch does not pollute your global feed's state.

Input

field	type	default	notes
mode	delta | snapshot	delta	delta = changes since your last run; snapshot = full export
search	string	""	registry search term; separate state timeline per term
enrichGithub	boolean	true	stars/forks/pushedAt/archived for GitHub-hosted servers
githubToken	secret string	—	your token → 5,000 req/hr. Without it enrichment is limited to delta rows, max 25 repos/run (GitHub's unauthenticated limit is 60 req/hr)
computeTrending	boolean	true	starsDelta + trendingRank vs your previous run
firstRunFullSnapshot	boolean	false	delta mode only; false = first run silently seeds state (run-start fee only), true = first run delivers the full registry at the snapshot rate
maxServers	integer	30000	hard cap on processed (and billed) rows per run

Output example (real row from a delta run)

{
  "serverName": "io.github.amyodov/yet-another-agentic-chat",
  "canonicalId": "repo:github.com/amyodov/yet-another-agentic-chat",
  "description": "Messaging between concurrent AI coding sessions, across clients, over MCP. Zero infrastructure.",
  "version": "0.5.0",
  "status": "active",
  "repositoryUrl": "https://github.com/amyodov/yet-another-agentic-chat",
  "repositorySource": "github",
  "packages": [{ "registry": "pypi", "name": "yet-another-agentic-chat", "version": "0.5.0" }],
  "remotes": [],
  "publishedAt": "2026-08-29T14:13:55.92155Z",
  "updatedAt": "2026-08-29T14:13:55.92155Z",
  "deltaType": "new",
  "ghStars": 3,
  "ghForks": 0,
  "ghPushedAt": "2026-08-29T14:22:29Z",
  "ghArchived": false,
  "starsDelta": null,
  "trendingRank": null,
  "firstSeenAt": "2026-08-29T14:35:44.971Z",
  "scrapedAt": "2026-08-29T14:35:44.971Z",
  "aliases": []
}

Field dictionary

field	type	notes
serverName	string	canonical registry name (e.g. io.github.owner/repo)
canonicalId	string	dedup key: normalized repo URL (+ monorepo subfolder) else name
description	string | null	from registry
version	string	latest version
status	string	active / deprecated / deleted
repositoryUrl	string | null
repositorySource	string | null	github / gitlab / other
packages	array	[{registry (npm/pypi/oci/...), name, version}]
remotes	array	[{transportType (sse/streamable-http), url}]
publishedAt / updatedAt	string	ISO 8601, from registry
deltaType	string | null	new / updated / deprecated / deleted; null on snapshot rows
ghStars / ghForks	integer | null	GitHub enrichment
ghPushedAt	string | null	GitHub enrichment
ghArchived	boolean | null	GitHub enrichment
starsDelta	integer | null	stars gained vs your previous run (needs ≥ 2 enriched runs)
trendingRank	integer | null	1 = biggest star gain among this run's rows
firstSeenAt	string	when your state first saw this server
scrapedAt	string	ISO 8601
aliases	array	previous/duplicate registry names collapsed into this row
raw	object	original registry entry — snapshot mode only (schema-drift safety net)

Pricing (pay per event)

event	price	charged for
Run start	$0.001	each run
Server snapshot row	$0.002	each row in snapshot mode (and the optional first-run snapshot)
Server delta row	$0.003	each new/updated/deprecated/deleted row in delta mode

Worked examples:

• Daily delta feed: typically tens to a few hundred changed servers/day → roughly $0.05–$0.60 per day.
• Full snapshot: the registry currently holds ~25,000+ latest-version servers, so a complete snapshot bills around $51. Use it sparingly (e.g. weekly reconciliation) or cap it with maxServers — the delta mode is the economical default.
• First delta run (default firstRunFullSnapshot: false): $0.001 total (seeds state, emits nothing).

You are never charged for rows that are not delivered to the dataset.

How long does a run take / recommended timeout

Measured on the Apify platform (4 GB, default build):

run type	duration (measured 2026-09-03)	recommended timeout
First delta run (default, silent seed)	~47 s	default 3600s (300s also works)
Daily delta run	~5 s – 1 min	default 3600s
Full snapshot (~25,000 rows)	~2–3 min (registry crawl ~45 s + batched delivery at 400–1,200 rows/s)	keep the default 3600s
Capped snapshot (maxServers: 500)	~30 s	300s is fine

maxServers bounds both cost and time — a maxServers: 500 snapshot bills at most 500 rows (~$1) and finishes in about a minute. GitHub enrichment with a token adds time proportional to the number of unique repos being enriched.

Timeouts, partial runs, and resurrection (no double billing)

The Actor watches its own run timeout and stops gracefully ~20–30s before the platform would kill it: it flushes a delivery checkpoint into the run's key-value store, finishes as SUCCEEDED, and sets a status message like Partial: 5,970 of ~25,000 rows delivered….

• Resurrect the same run (Runs > ⋯ > Resurrect, pick a longer timeout) and it continues where it left off. Already-delivered rows are never re-pushed and never re-charged — the checkpoint lives in the run's own storage and the flat run-start fee is charged at most once per run.
• In delta mode, even a fresh follow-up run continues cleanly: delivered rows are recorded in your delta state, so they are not billed again unless they change.
• Rows are charged strictly after they are written to the dataset, in batches: a row that never reached your dataset is never billed.

Data sources & respect

• registry.modelcontextprotocol.io — the official, public, OpenAPI-documented registry of the Model Context Protocol open-source project. Full credit to the MCP project for the data. The Actor uses plain HTTP JSON pagination with a descriptive User-Agent, a small delay between pages (the registry's cursor pagination is inherently sequential), and exponential backoff honoring Retry-After on errors. No PII is collected (server metadata only).
• api.github.com — optional enrichment. Bring your own token for full coverage; without one the Actor stays well inside GitHub's unauthenticated limit and stops gracefully if the limit is hit (partial enrichment noted in the run status).
• PulseMCP and Glama are not included: PulseMCP's API is being sunset, and Glama's requires an API key with attribution requirements.

Limitations (honest)

• Registry metadata quality varies by publisher — many servers have no repository URL or packages.
• Trending needs at least 2 runs with GitHub enrichment before starsDelta/trendingRank are non-null.
• No download counts — no open source for MCP server download numbers currently exists.
• Deletion detection via disappearance requires a previous complete snapshot in state; the registry's own status: deleted/deprecated markers are picked up in every delta run.
• Delta state is per Apify account (named key-value store mcp-registry-state) and per search term.

Support

Report problems in the Actor's Issues tab — responses within 24 hours. If the registry API shape drifts, the built-in contract test fails the run loudly instead of emitting malformed data.