Publish your MCP server to the official registry.
One server.json manifest in the official MCP registry gets you indexed by Loomal and every other downstream catalog. The publish flow is a CLI login and one command — the work is getting the manifest right.
The official MCP registry is the canonical, machine-readable catalog of MCP servers. You publish one manifest — server.json — describing your server's name, packages, and remote endpoints, and downstream consumers index it from there. Loomal imports from the official registry, so publishing there is how your server gets a Loomal listing without you creating one by hand.
This guide covers the manifest, namespace authentication, and what happens after you publish. Details below reflect the registry as of mid-2026; the registry docs are the source of truth for current flags and schema versions.
Understand what the registry is — and isn't
The registry stores metadata, not code. Your actual server still lives on npm, PyPI, an OCI registry, or behind a remote URL; server.json just tells clients where to find it and how to run it. That separation is why one manifest can describe an npm package and a hosted streamable HTTP endpoint at the same time.
Names are namespaced to prove ownership. A server published as io.github.yourname/server-name requires authenticating as that GitHub user or org; DNS-based namespaces (com.yourcompany/*) verify through a domain record instead.
Write the server.json manifest
The manifest needs a namespaced name, a one-line description, a version, and at least one distribution: a packages entry for installable servers or a remotes entry for hosted ones. Declare your environment variables and arguments here too — clients use this metadata to generate working configs, so an undeclared required variable means broken installs downstream.
Keep the description concrete; it's what every downstream index, Loomal included, displays before anyone reads your README.
{
"$schema": "https://static.modelcontextprotocol.io/schemas/2025-09-29/server.schema.json",
"name": "io.github.acme/court-records",
"description": "Search US court filings by case number, party, or judge",
"version": "1.2.0",
"packages": [
{
"registryType": "npm",
"identifier": "@acme/court-records-mcp",
"version": "1.2.0",
"transport": { "type": "stdio" },
"environmentVariables": [
{ "name": "COURT_API_KEY", "description": "API key for the records backend", "isRequired": true, "isSecret": true }
]
}
]
}Authenticate and publish with mcp-publisher
The registry ships a CLI, mcp-publisher, that handles the whole flow: 'mcp-publisher init' scaffolds a manifest, 'mcp-publisher login github' authenticates you for the io.github.* namespace, and 'mcp-publisher publish' validates and submits it.
Validation is strict on purpose. The most common rejections are a name that doesn't match your authenticated namespace and a packages identifier that doesn't exist on the package registry yet — publish to npm or PyPI first, then to the MCP registry.
Version updates are re-publishes
The registry keeps a version history rather than mutating entries, so shipping an update means bumping the version in server.json and running publish again. Wiring this into your release pipeline — publish to npm, then to the registry, in one CI job — keeps the manifest from drifting behind your actual releases.
Drift matters downstream: indexes show whatever you last published, and a manifest advertising a two-versions-old package quietly misconfigures every new install.
After publishing: claim your Loomal listing
Once your entry is live in the official registry, Loomal's import picks it up and creates a marketplace listing from your manifest metadata. That listing exists whether or not you do anything next — but it's unclaimed.
Claiming it through GitHub ownership verification lets you connect the running server so Loomal probes and publishes your live tool list, and lets you attach a per-call x402 price (from $0.01) if you want agents to pay for calls. One manifest, then: registry entry, Loomal listing, and a payment path.
FAQ
Do I have to publish my package to npm before the registry?
Yes, if your manifest declares an npm package — the registry validates that the identifier and version actually exist. The same applies to PyPI and OCI distributions. Remote-only servers skip this entirely and declare a remotes entry with the hosted endpoint URL instead.
What does publishing to the official registry cost?
Nothing — it's a free, open catalog run as part of the MCP project. Monetization happens downstream: if you want to charge agents per call, you do that by claiming your Loomal listing and setting an x402 price, which starts at $0.01 per call.
How long until my server shows up on Loomal?
Loomal imports from the official registry on a recurring basis, so new entries appear after the next import cycle rather than instantly. If you want it live faster, see the guide on getting indexed faster — and claim the listing once it appears so it carries your live tool list.
Can I publish a server I host remotely with no installable package?
Yes. Use a remotes entry in server.json with your streamable HTTP endpoint URL instead of a packages entry. Namespace rules still apply, so you'll authenticate via GitHub or a DNS record depending on the name you choose.
See where your manifest ends up.
Browse real registry-imported servers on the Loomal marketplace.