DEV Community

Fast Data
Fast Data

Posted on

How to list a remote MCP server in the official MCP Registry with a GitHub Action (no secrets, 14-second publishes)

The official MCP Registry now lists more than 64,000 servers. Getting your own entry in is easier than it looks, especially if your server is already hosted somewhere: you do not publish code, you publish a small server.json that points at a remote endpoint. Here is the setup we have used for five versions in three weeks, with the real run times and the one failure we caused ourselves.

Disclosure: I build data tools for AI agents as Fast Data on Apify. Our registry entry points at Apify's hosted MCP server with our tools preselected; the files below are in our public data-recipes repo.

The server.json for a remote server

{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "io.github.ichkifokkus/fast-data",
  "title": "Fast Data Actors (via Apify MCP)",
  "description": "German/EU e-invoices, IBAN/VAT/BaFin checks, tenders, hiring signals and more via Apify",
  "repository": { "url": "https://github.com/ichkifokkus/data-recipes", "source": "github", "subfolder": "mcp" },
  "version": "1.1.3",
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://mcp.apify.com/?tools=fast_data_asap/iban-validator-bank-lookup,fast_data_asap/eu-vat-number-validator",
      "headers": [
        {
          "name": "Authorization",
          "description": "Apify API token, e.g. 'Bearer <token>'. Optional for clients that support OAuth.",
          "isRequired": false,
          "isSecret": true
        }
      ]
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

(The real file lists 18 tools in the URL; shortened here.)

Field What to know
name Namespace and name. io.github.<user>/… is what GitHub-based auth lets you publish; a custom domain namespace needs DNS or HTTP verification instead.
version Must change on every publish. The registry keeps every version and marks the newest as latest.
remotes[].type streamable-http for a hosted endpoint. Local servers use packages (npm, PyPI, …) instead.
headers[] Declares what a client must send. isSecret: true tells clients to treat it as a credential and never log it.
description Short. It is what people see in registry listings and client UIs.

The workflow: GitHub OIDC, no stored secrets

The registry accepts a GitHub Actions OIDC token as proof that the workflow runs in the repository that owns the io.github.<user> namespace. No API key goes into the repo or the secrets store.

name: Publish to MCP Registry
on:
  push:
    branches: [main]
    paths: [server.json]
  workflow_dispatch:

jobs:
  publish:
    runs-on: ubuntu-latest
    permissions:
      id-token: write   # required for mcp-publisher login github-oidc
      contents: read
    env:
      MCP_PUBLISHER_VERSION: v1.8.8
    steps:
      - uses: actions/checkout@v5
      - uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6  # v4.1.2
      - name: Download and verify mcp-publisher
        run: |
          set -euo pipefail
          archive="mcp-publisher_linux_amd64.tar.gz"
          base="https://github.com/modelcontextprotocol/registry/releases/download/${MCP_PUBLISHER_VERSION}"
          curl -fsSL -o "$archive" "$base/$archive"
          curl -fsSL -o "$archive.sigstore.json" "$base/$archive.sigstore.json"
          cosign verify-blob --bundle "$archive.sigstore.json" \
            --certificate-identity "https://github.com/modelcontextprotocol/registry/.github/workflows/release.yml@refs/tags/${MCP_PUBLISHER_VERSION}" \
            --certificate-oidc-issuer "https://token.actions.githubusercontent.com" "$archive"
          tar xzf "$archive" mcp-publisher
      - run: ./mcp-publisher validate
      - run: ./mcp-publisher login github-oidc
      - run: ./mcp-publisher publish
Enter fullscreen mode Exit fullscreen mode

Three choices worth copying:

  • Trigger on paths: [server.json]. A publish happens exactly when the entry changes, never on unrelated commits.
  • Pin the publisher version and verify its signature. Downloading releases/latest and running it with an OIDC token in scope is a supply-chain risk; cosign checks that the binary was built by the registry's own release workflow.
  • validate before login. Schema errors fail fast without touching the registry.

What it looked like in practice

Version Published (UTC) What changed
1.0.0 22 Oct, 20:29 first entry
1.1.0 8 Nov, 13:46 finance and sales tools added
1.1.1 8 Nov, 20:22 EU tenders tool
1.1.2 10 Nov, 09:31 company check tool
1.1.3 11 Nov, 09:29 exchange-rate converter

Each successful run took 11 to 14 seconds from start to finish. You can check your own entry, including every version, with one public call:

curl -s "https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.ichkifokkus" \
  | python3 -c "import json,sys; [print(s['server']['version'], s['_meta']['io.modelcontextprotocol.registry/official']['isLatest']) for s in json.load(sys.stdin)['servers']]"
Enter fullscreen mode Exit fullscreen mode

The error you will cause yourself

On 8 November I re-ran the workflow manually twice, 13 minutes after 1.1.0 had gone through. Both runs failed. The server.json on that commit still said "version": "1.1.0", and the registry does not accept a version that already exists. Nothing was broken; the entry was already live.

The fix is procedural: bump version in the same commit as the change. Since the workflow triggers on server.json, a forgotten bump means the publish step fails, and a manual re-run of the same commit cannot help.

What a registry entry does not do

  • It does not host anything. The URL in remotes must already work; the registry only stores metadata.
  • It is not a quality signal. With roughly 670 new servers a day, a listing alone gets little attention. Clear descriptions and a useful tool set matter more.
  • It does not handle auth for you. Declaring a header tells clients what to send; your endpoint still has to check it.

Try it

Copy server.json and .github/workflows/publish-mcp.yml from our data-recipes repo, change the namespace, URL and description, and push. The entry shows up in the registry API within seconds of a green run.

Question: for those publishing local servers via packages: do you publish a registry version on every package release, or only when the tool surface changes? We bump on every tool change, but I am not sure that scales.

Top comments (0)