# MCP Servers List: Official MCP Registry Monitor (`maliksaid/mcp-registry-monitor`) Actor

List and monitor MCP servers from the official Model Context Protocol registry. One row per server version: name, version, status, dates, repository, npm and PyPI packages, install command, transports, remote URLs and tool names. Find new MCP servers and tools for AI agents. Change-only monitor.

- **URL**: https://apify.com/maliksaid/mcp-registry-monitor.md
- **Developed by:** [Malik Said](https://apify.com/maliksaid) (community)
- **Categories:** AI, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 server versions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## MCP Servers List: Official MCP Registry Monitor

This Actor gives you a list of MCP servers from the official MCP Registry at registry.modelcontextprotocol.io. It returns one row per MCP server version. Each row has the server name, version, status, dates, repository, packages, transports and remote URLs.

Use it to find new Model Context Protocol servers, build an MCP directory or a catalog of tools for AI agents, or watch for new versions of the servers you depend on. Turn on monitor mode and schedule it. Each run then returns only new servers, new versions and status changes.

### MCP registry coverage

| Item | Count on 21 October 2026 |
|---|---|
| Servers (latest version of each) | 47,547 |
| Latest versions that offer a remote endpoint (streamable-http or sse) | 30,991 |
| Latest versions that publish a package (npm, PyPI, OCI, NuGet, MCPB, Cargo) | 18,297 |

Counts come from a full test run. They grow every day.

### MCP server data returned

| Field | Meaning |
|---|---|
| `id` | Server name and version. Unique per row |
| `name` | Server name in reverse-DNS form, for example `io.github.owner/server` |
| `namespace` | The part of the name before the slash |
| `title`, `description` | Display title and short description from the publisher |
| `version` | Version of this row |
| `status` | `active`, `deprecated` or `deleted` |
| `publishedAt`, `updatedAt`, `statusChangedAt` | Registry dates, ISO 8601 |
| `isLatest` | True when this is the newest version of the server |
| `websiteUrl`, `repositoryUrl` | Links set by the publisher |
| `transportTypes` | Every transport offered: `stdio`, `streamable-http` or `sse` |
| `packageRegistryTypes`, `packageIdentifiers` | Package registries and package names |
| `packages` | Each package with version, transport, runtime hint and the names of the environment variables it reads |
| `remoteUrls`, `remotes` | Hosted endpoints and their transport |
| `installCommand` | Command that starts the first package, for example `npx -y name@1.0.0`, `uvx name==1.0.0` or `docker run -i --rm image:1.0.0`. Null when no standard form exists |
| `remoteHosts` | Host names of the hosted endpoints, without duplicates |
| `toolNames`, `toolCount` | Tools a hosted server lists. Only with **Read tool lists** on |
| `protocolVersion`, `authRequired`, `toolsError` | MCP version the server answered with, whether it asked for a login, and why a list could not be read |
| `hasRemote` | True when the server has at least one hosted endpoint |
| `changeType` | Monitor mode only: `new-server`, `new-version` or `status-changed` |
| `registryUrl` | API link to this exact version in the registry |
| `scrapedAt` | When the Actor collected the row |

Empty fields are `null` or `[]`. The publisher left them unset. Many servers have no title, repository or package. Remote-only servers have no packages.

### How to use the MCP server list

1. Run it with the default input to see the first 100 servers.
2. Add filters. For example, set **Transport types** to `streamable-http` to list hosted servers only.
3. Set **Maximum server versions** to 0 for the whole registry.
4. Turn on **Monitor mode** and schedule the Actor, for example once a day. The first run returns everything that matches. Later runs return only new servers, new versions and status changes.

Monitor mode remembers what it returned under the **Monitor state key**. Use a different key for each watch list. Later monitor runs ask the registry only for versions updated since the last complete run, so they finish fast.

| Option | Default | Meaning |
|---|---|---|
| Keywords | None | Keep servers whose name, title or description contains a keyword |
| Server name contains | None | The registry filters names by this text. Pages can be slow |
| Updated since | None | A date, a timestamp, or a period such as `7 days` |
| Latest version only | On | Turn off to get every version |
| Transport types | All | `stdio`, `streamable-http`, `sse` |
| Package registry types | All | `npm`, `pypi`, `oci`, `nuget`, `mcpb`, `cargo` |
| Include deleted servers | Off | Also return versions the registry marked as deleted |
| Read tool lists of hosted servers | Off | Connect to each hosted (streamable-http) server and read its tool list. Slower |
| Monitor mode | Off | Return only new and changed versions |
| Monitor state key | `default` | Name of the monitor memory |
| Maximum server versions | 100 | Stop after this many rows. Set 0 for no limit |
| Maximum API pages | 0 (all) | Each page holds 100 rows. For quick tests |

A full scan of the latest versions read 476 pages and took about 32 minutes in our test. For a full scan (`maxItems: 0`), set the run memory to 512 MB in the run options. A test of the whole registry (49,061 server versions) peaked at about 180 MB, which is close to the 256 MB default. The default run timeout is 3,600 seconds. A scan of every version holds more rows and can need a longer timeout. Use monitor mode or Updated since for regular runs.

### MCP registry monitor pricing

The Actor uses pay-per-event pricing.

| Event | Free plan | GOLD plan and higher |
|---|---|---|
| Run start | $0.005 | $0.005 |
| Server version | $0.002 ($2.00 per 1,000) | $0.0016 ($1.60 per 1,000) |

| Server versions in one run | Free plan | GOLD plan and higher |
|---|---|---|
| 100 | $0.205 | $0.165 |
| 1,000 | $2.005 | $1.605 |

Costs include the run start fee.

The start fee is charged once per GB of run memory, at least once. The default memory is 256 MB, so most runs pay it once. Rows skipped by your filters cost nothing. In monitor mode you pay only for new and changed rows.

### Input and output example

Input from a real run on 21 October 2026:

```json
{
  "nameSearch": "io.github.mc",
  "latestOnly": true,
  "maxItems": 20
}
```

The first output row from that run:

```json
{
  "id": "io.github.MCFLAMINGO/local-intel@1.2.0",
  "name": "io.github.MCFLAMINGO/local-intel",
  "namespace": "io.github.MCFLAMINGO",
  "title": null,
  "description": "Hyperlocal business intelligence for AI agents. 20 MCP tools. Florida-first, Sunbelt expansion.",
  "version": "1.2.0",
  "status": "active",
  "publishedAt": "2026-04-24T05:45:55.017614Z",
  "updatedAt": "2026-04-24T05:45:55.017614Z",
  "isLatest": true,
  "repositoryUrl": "https://github.com/MCFLAMINGO/gsb-swarm",
  "transportTypes": ["streamable-http", "sse"],
  "packageRegistryTypes": [],
  "packages": [],
  "remoteUrls": ["https://gsb-swarm-production.up.railway.app/api/local-intel/mcp"],
  "installCommand": null,
  "remoteHosts": ["gsb-swarm-production.up.railway.app"],
  "hasRemote": true,
  "changeType": null,
  "registryUrl": "https://registry.modelcontextprotocol.io/v0.1/servers/io.github.MCFLAMINGO%2Flocal-intel/versions/1.2.0"
}
```

### MCP servers FAQ

#### Can I see the tools each server offers?

Yes, for hosted servers. Turn on **Read tool lists of hosted servers**. The Actor connects to each streamable-http endpoint, sends `initialize` and `tools/list`, and saves the tool names. It never calls a tool and sends no keys or tokens. Servers that ask for a login get `authRequired: true`. robots.txt is respected. Servers that only run locally (stdio packages) have no tool list here.

#### What is the MCP Registry?

It is the official public catalog of Model Context Protocol servers. Publishers register each server there with its packages and endpoints.

#### How do I get only new MCP servers?

Turn on monitor mode and schedule the Actor daily. Each run returns rows with `changeType` set to `new-server`, `new-version` or `status-changed`.

#### Can I list only hosted MCP servers?

Yes. Set **Transport types** to `streamable-http` or `sse`. Every row then has at least one remote URL.

#### How do I install a server from the list?

Copy `installCommand`. It starts the server's first package, for example `npx -y name@1.0.0` for npm or `uvx name==1.0.0` for PyPI. Add the server's own arguments and the environment variables listed in `packages`. Hosted servers have no command. Connect to a URL in `remoteUrls` instead.

#### Does it read API keys or secrets?

No. It saves only the names of the environment variables a package reads. Values, defaults and headers are never collected.

#### How often should I run it?

The registry asks aggregators to read it about once per hour at most. A daily schedule suits most uses.

#### Can AI agents use it?

Yes. An agent can search the list by keyword or transport and get flat JSON rows with install and endpoint details.

### Data source and use

- All data comes from the public API of the official MCP Registry. It needs no login or key.
- The registry publishes its server metadata under CC0 1.0. This Actor has no affiliation with the MCP Registry.
- The Actor reads one page at a time.

### Related Actors

- [Regulator Circulars Monitor](https://apify.com/maliksaid/regulator-circulars-monitor): track new circulars from the Central Bank of Jordan and the Saudi National Cybersecurity Authority.
- [Drug Approvals Monitor](https://apify.com/maliksaid/drug-approvals-monitor): track new drug approvals from the FDA, EMA and Health Canada.
- [Technical SEO Audit](https://apify.com/maliksaid/technical-seo-audit): crawl a website and find technical SEO problems.

### Support

Report a problem in the Issues tab. Include the run link.

# Actor input Schema

## `keywords` (type: `array`):

Keep only servers whose name, title or description contains at least one keyword. Keywords match whole words, for example "postgres" or "github". Leave empty to keep every server.

## `nameSearch` (type: `string`):

Ask the registry for servers whose name contains this text, for example "io.github." or "slack". The registry filters by name only. Name searches can take up to a minute or more per page on the registry side.

## `updatedSince` (type: `string`):

Return only server versions published or updated on or after this point. Use a date (2026-10-01), a timestamp (2026-10-01T12:00:00Z) or a period (7 days, 24 hours). Leave empty for all dates.

## `latestOnly` (type: `boolean`):

Return only the latest version of each server. Turn off to get every published version, one row per version.

## `transportTypes` (type: `array`):

Keep only servers that offer at least one of these transports. Leave empty to keep all.

## `packageRegistryTypes` (type: `array`):

Keep only servers that publish a package in at least one of these registries. Leave empty to keep all, including remote-only servers.

## `includeDeleted` (type: `boolean`):

Also return versions with status "deleted". The registry deletes servers that break its moderation policy.

## `includeTools` (type: `boolean`):

For hosted servers with a streamable-http endpoint, connect once and read the list of tools (initialize and tools/list only; no tool is ever called). Servers that ask for a login are marked and skipped. robots.txt is respected. Adds up to 15 seconds per server, 5 servers at a time.

## `monitorMode` (type: `boolean`):

Return only new servers, new versions and status changes since the last monitor run with the same state key. The first run returns everything that matches. Schedule the Actor with this on to get a change feed.

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

Name of the memory that monitor mode uses. Use a different key for each separate watch list.

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

Stop after saving this many server versions. The default keeps test runs short and cheap. Set 0 for no limit.

## `maxPages` (type: `integer`):

Limit how many registry pages of 100 records are read. 0 means all pages.

## Actor input object example

```json
{
  "keywords": [],
  "latestOnly": true,
  "transportTypes": [],
  "packageRegistryTypes": [],
  "includeDeleted": false,
  "includeTools": false,
  "monitorMode": false,
  "stateKey": "default",
  "maxItems": 100,
  "maxPages": 0
}
```

# 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 = {
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maliksaid/mcp-registry-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 = { "maxItems": 100 }

# Run the Actor and wait for it to finish
run = client.actor("maliksaid/mcp-registry-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 '{
  "maxItems": 100
}' |
apify call maliksaid/mcp-registry-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maliksaid/mcp-registry-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/gegfIf8H9yMcAoFvi/builds/9a1Nvlm5YAQT5gwe6/openapi.json