# GitHub MCP Registry Servers Scraper (`automation-lab/github-mcp-registry-catalog`) Actor

Search and export official MCP Registry server records with publisher, repository, package, endpoint, transport, version, and lifecycle metadata.

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

## Pricing

from $0.54 / 1,000 item extracteds

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?

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

## GitHub MCP Registry Servers Scraper

Search and export **GitHub MCP Registry servers** from the official public MCP Registry API. Get normalized server identity, publisher namespace, description, version, GitHub repository, package installation, remote endpoint, transport, and lifecycle metadata in an Apify dataset.

Use the Actor for MCP tool discovery, integration evaluation, version inventory, and scheduled ecosystem monitoring. It calls the stable public Registry API directly—no GitHub login, MCP Registry token, browser, or proxy is required.

### What does this Actor do?

The Actor supports four practical workflows:

1. Search the official registry by text.
2. Browse latest server versions with cursor pagination.
3. Retrieve exact servers by their reverse-DNS registry names.
4. Export records changed after an ISO timestamp for incremental monitoring.

Every accepted row is normalized into one stable dataset shape. Package options and remote endpoints remain structured, while compact `installationMethods` and `transportTypes` fields make spreadsheet analysis easy.

### Who is it for?

- **AI platform teams** comparing available MCP integrations.
- **Developer-relations teams** tracking ecosystem adoption and new publishers.
- **Security and procurement analysts** locating repositories and authentication requirements before deeper review.
- **Data teams** building a recurring MCP catalog in a warehouse or spreadsheet.
- **MCP client developers** testing discovery and installation metadata across published servers.

This is a catalog exporter, not an MCP client or security scanner. It does not connect to a listed server or assert that third-party code is safe.

### Why use this official registry catalog?

- Uses the official `registry.modelcontextprotocol.io` v0.1 JSON API.
- Supports both discovery and deterministic exact-name retrieval.
- Reuses opaque upstream pagination cursors correctly.
- Filters for GitHub-linked repositories when needed.
- Omits remote header values and exposes only header names/authentication indicators.
- Charges only records accepted and saved to the dataset.
- Needs only 256 MB of memory and no paid proxy traffic.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `serverName` | Official reverse-DNS server identity |
| `title`, `description` | Publisher-provided display metadata |
| `version`, `isLatest` | Published version and latest-version flag |
| `publisher` | Namespace before the `/` in `serverName` |
| `repositoryUrl` | Declared public source repository |
| `repositorySource` | Repository host identifier, such as `github` |
| `repositorySubfolder` | Server location inside a monorepo |
| `websiteUrl` | Project, documentation, or homepage URL |
| `packages` | Package registry, identifier, version, and transport |
| `remotes` | Remote URL, transport, and authentication indicator |
| `installationMethods` | Compact package and remote connection choices |
| `transportTypes` | Distinct `stdio`, SSE, or streamable HTTP transports |
| `status`, `statusMessage` | Official lifecycle state and explanation |
| `publishedAt`, `updatedAt` | Registry publication/update timestamps |
| `canonicalUrl` | Official API URL for the exact server version |
| `scrapedAt` | Time the Actor saved the row |

The official API currently has no controlled category taxonomy. The Actor does not invent categories from descriptions.

### How to get started

1. Open the Actor in Apify Console.
2. Enter a `query`, exact `serverNames`, or leave both empty to browse.
3. Choose whether to keep only GitHub-linked repositories.
4. Leave **Latest versions only** enabled for normal discovery.
5. Set `maxItems` to the number of accepted rows you need.
6. Click **Start**.
7. Open the **Dataset** tab to export JSON, CSV, Excel, XML, or RSS.

The prefilled `github` search is a low-cost first run and returns real public records.

### Input parameters

#### `query`

Optional text search, up to 200 characters. The Registry API performs discovery; the Actor applies the same text scope again to normalized names, titles, descriptions, publishers, and links.

#### `serverNames`

Up to 100 exact names, for example:

```json
["io.github.github/github-mcp-server"]
```

Exact-name mode avoids catalog pagination. If `latestOnly` is false, it can return version history for each supplied name.

#### `repositorySource`

- `all` — keep every matching server.
- `github` — keep only records whose repository source is GitHub.
- `other` — keep records linked elsewhere or without a GitHub repository declaration.

#### `latestOnly`

Defaults to `true`. Disable it when exact-name version history is the intended output. Large all-version catalog exports can contain several rows per server.

#### `updatedSince`

An ISO 8601 checkpoint such as `2026-09-01T00:00:00.000Z`. Use it in browse/search mode for scheduled incremental exports.

#### `includeDeleted`

Includes records carrying the official `deleted` lifecycle status. This is most useful with `updatedSince`.

#### `maxItems`

An integer from 1 to 5,000. The limit applies after filters and deduplication, not merely to raw upstream responses.

### Example inputs

Search GitHub-related integrations:

```json
{
  "query": "github",
  "latestOnly": true,
  "repositorySource": "all",
  "maxItems": 10
}
```

Retrieve the official GitHub MCP Server:

```json
{
  "serverNames": ["io.github.github/github-mcp-server"],
  "repositorySource": "github",
  "latestOnly": true,
  "maxItems": 5
}
```

Export recent changes for downstream comparison:

```json
{
  "updatedSince": "2026-09-01T00:00:00.000Z",
  "includeDeleted": true,
  "latestOnly": true,
  "maxItems": 25
}
```

### Output example

A current exact-name run returns a row shaped like this:

```json
{
  "serverName": "io.github.github/github-mcp-server",
  "title": "GitHub",
  "description": "Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.",
  "version": "1.12.0",
  "publisher": "io.github.github",
  "repositoryUrl": "https://github.com/github/github-mcp-server",
  "repositorySource": "github",
  "packages": [{
    "registryType": "oci",
    "identifier": "ghcr.io/github/github-mcp-server:1.12.0",
    "transportType": "stdio"
  }],
  "remotes": [{
    "type": "streamable-http",
    "url": "https://api.githubcopilot.com/mcp/",
    "authenticationRequired": true,
    "headerNames": ["Authorization"]
  }],
  "status": "active",
  "isLatest": true,
  "canonicalUrl": "https://registry.modelcontextprotocol.io/v0.1/servers/io.github.github%2Fgithub-mcp-server/versions/1.12.0"
}
```

Version numbers and metadata can change whenever publishers update the registry.

### How much does it cost to export registry servers?

The Actor uses pay-per-event pricing:

- **Start:** $0.00005 once per run.
- **MCP server record:** $0.0009 per accepted record on the BRONZE plan.

At current BRONZE pricing, 10 records cost about **$0.00905**, 100 records cost about **$0.09005**, and 1,000 records cost about **$0.90005**, excluding any plan-specific platform usage arrangements. Higher plans receive the tier displayed in Apify Console. Failed, rejected, duplicate, and empty rows do not incur the per-record event.

These examples will be kept aligned with the applicable live Actor pricing.

### Pagination, limits, and retries

The Actor requests up to 100 upstream rows at a time and passes the Registry's opaque `nextCursor` back unchanged. It keeps paging until `maxItems` accepted rows are saved or the API is exhausted.

Network errors, HTTP 429, and temporary 5xx responses receive up to three attempts with exponential backoff and jitter. Stable client errors are not retried blindly. Exhaustion fails the run instead of returning a misleading empty success.

### Monitoring ecosystem changes

Schedule an Apify Task with `updatedSince` and save each run's dataset to your data platform. Advance the checkpoint only after a successful run. Include deleted records if lifecycle removal matters to your inventory.

The Actor exports snapshots. It does not persist cross-run state, calculate diffs, send alerts, or guarantee that a publisher's external repository remains unchanged. Use Apify schedules and integrations to implement those downstream steps.

### Export and integration ideas

- Send new records to Google Sheets for a lightweight catalog.
- Load datasets into BigQuery, Snowflake, or PostgreSQL.
- Trigger a webhook when a scheduled run succeeds.
- Compare `serverName`, `version`, `status`, and `updatedAt` against the previous checkpoint.
- Feed GitHub-linked `repositoryUrl` values into a separate repository intelligence workflow.
- Review `authenticationRequired` before adding endpoints to an approved integration list.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~github-mcp-registry-catalog/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"query":"github","latestOnly":true,"maxItems":10}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/github-mcp-registry-catalog').call({
  query: 'github',
  latestOnly: true,
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/github-mcp-registry-catalog').call(run_input={
    'query': 'github',
    'latestOnly': True,
    'maxItems': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use through MCP

#### Claude Code

Add this exact Actor through Apify's MCP server:

```bash
claude mcp add --transport http https://mcp.apify.com?tools=automation-lab/github-mcp-registry-catalog
```

#### Claude Desktop

Add an HTTP MCP server with the Actor-scoped URL shown below.

#### Cursor and VS Code

In Cursor or VS Code MCP settings, use the same HTTP server configuration:

```json
{
  "mcp": {
    "servers": {
      "apify-github-mcp-registry": {
        "url": "https://mcp.apify.com/?tools=automation-lab/github-mcp-registry-catalog",
        "headers": { "Authorization": "Bearer your-apify-token" }
      }
    }
  }
}
```

Claude Desktop clients that use the `mcpServers` key can use:

```json
{
  "mcpServers": {
    "apify-github-mcp-registry": {
      "url": "https://mcp.apify.com/?tools=automation-lab/github-mcp-registry-catalog",
      "headers": { "Authorization": "Bearer your-apify-token" }
    }
  }
}
```

#### Example prompts

- “Search the official MCP Registry for GitHub integrations and return 20 latest records.”
- “Export the latest record for `io.github.github/github-mcp-server`.”
- “Find registry records updated since 2026-09-01 and include deleted entries.”

### Legality

The Actor reads public software catalog metadata. Follow the Registry API's terms and applicable laws. Repository links and remote endpoints are publisher-provided and may lead to third-party services with separate terms.

Do not treat presence in the registry as a security approval. Inspect source, package provenance, requested credentials, endpoint policies, and licenses before installation. The Actor intentionally does not return configured remote header values.

### Limitations

- Metadata freshness depends on the official MCP Registry API.
- The registry does not expose a controlled category taxonomy.
- Descriptions, websites, repositories, packages, and endpoints are optional publisher-provided fields.
- Search semantics belong partly to the upstream API and can change.
- Exact-name errors are logged and skipped so one removed name does not discard other requested names.
- The Actor does not test server availability, enumerate tools, scan source code, or verify publisher identity.
- `repositorySource: github` excludes records whose publishers omitted repository metadata even if their description mentions GitHub.

### Troubleshooting

#### Why did my search return fewer rows than `maxItems`?

The upstream search may contain fewer matching records, or `repositorySource` and lifecycle filters may reject rows. Try `repositorySource: all` or a broader query.

#### Why is an exact server missing?

Check its full reverse-DNS name and Actor logs. Names must contain exactly one `/`. The record may have been removed or may not satisfy your query/repository filter.

#### Why did the run fail instead of returning an empty dataset?

A persistent API/network error is operationally different from a valid no-result search. The Actor fails after bounded retries so scheduled workflows do not mistake an outage for an empty registry.

#### Can I retrieve old versions?

Yes. Supply exact `serverNames` and set `latestOnly` to `false`. Limit the result with `maxItems`.

### Related Automation Lab Actors

- [GitHub Scraper](https://apify.com/automation-lab/github-scraper) for broader repository, issue, and contributor workflows after catalog discovery.
- [GitHub Contributors Scraper](https://apify.com/automation-lab/github-contributors-scraper) for public contributor analysis on selected repositories.
- [GitHub Trending Scraper](https://apify.com/automation-lab/github-trending-scraper) for trending repository rankings rather than MCP Registry records.

### FAQ

#### Is this the GitHub website search API?

No. It reads the official MCP Registry API. “GitHub” describes the demanded discovery workflow and the repository links exposed by many records; use `repositorySource: github` when only GitHub-linked entries are needed.

#### Does it require a GitHub token?

No. Neither the official public Registry API nor this Actor requires a GitHub login or token.

#### Does it install or call MCP servers?

No. It exports discovery and setup metadata only.

#### Are remote endpoints guaranteed to work?

No. Endpoint values are publisher-provided snapshots. Availability and authentication must be evaluated separately.

#### Can I export CSV or Excel?

Yes. Open the run dataset and select the desired export format, or use the dataset API with format parameters.

#### Can I monitor new or deleted servers?

Use a scheduled Task with `updatedSince` and `includeDeleted`. Store or compare successive datasets in your downstream system.

# Actor input Schema

## `query` (type: `string`):

Text matched against official registry names, titles, descriptions, publishers, and public links. Leave empty to browse the catalog.

## `serverNames` (type: `array`):

Optional exact reverse-DNS registry names. When supplied, these records are retrieved directly instead of browsing the catalog.

## `repositorySource` (type: `string`):

Return all records, only records linked to GitHub repositories, or records not linked to GitHub.

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

Return only the latest published version of each server. Disable this for version-history exports.

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

Optional ISO 8601 date-time for incremental monitoring runs. Supported for catalog/search mode.

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

Include registry records marked deleted. Useful with updatedSince for lifecycle monitoring.

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

Maximum number of accepted server-version records to save after filters.

## Actor input object example

```json
{
  "query": "github",
  "serverNames": [],
  "repositorySource": "all",
  "latestOnly": true,
  "includeDeleted": false,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized MCP server versions, repositories, packages, endpoints, and lifecycle metadata.

# 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 = {
    "query": "github",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/github-mcp-registry-catalog").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 = {
    "query": "github",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/github-mcp-registry-catalog").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 '{
  "query": "github",
  "maxItems": 20
}' |
apify call automation-lab/github-mcp-registry-catalog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/github-mcp-registry-catalog"
        }
    }
}

```

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/J60MG5wf0OCGDMVRv/builds/zmX825f1bF3XPiSqm/openapi.json