---
title: "MCP marketplaces, where to submit, what each one auto-pulls | Recipe — StudioMeyer Academy"
description: "mcp.so, MCPize, awesome-mcp-servers, Smithery, Glama. Submission process, what each directory auto-pulls from your README, how to spot fake-traffic ones."
canonical: "https://studiomeyer.academy/en/recipes/9.3-mcp-marketplaces"
language: en
markdown_versions: ["https://studiomeyer.academy/en/recipes/9.3-mcp-marketplaces.md"]
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Recipes](https://studiomeyer.academy/recipes)

Phase 9 · Distribution·9 steps

# MCP marketplaces, where to submit, what each one auto-pulls

mcp.so, MCPize, awesome-mcp-servers, Smithery, Glama. Submission process, what each directory auto-pulls from your README, how to spot fake-traffic ones.

9 steps0%

Du liest ohne Account. Mit [Login](https://studiomeyer.academy/login?next=/recipes/9.3-mcp-marketplaces) speichern wir Step-Fortschritt + Notes.

# MCP marketplaces, where to submit, what each one auto-pulls

After your server is on npm + GitHub, the question is: how do users find it? The MCP ecosystem has ~7 directories that matter, plus a long tail of low-traffic ones. This recipe is the priority order, the submission flow per directory, and how to recognize the ones that aren't worth your time.

### Step 1: Priority order (Q2 2026)

| Directory | Approx. server count | Submission | Auto-pulls from | |---|---|---|---| | **Official MCP Server Registry** (`registry.modelcontextprotocol.io`) | Authoritative, downstream sync source | `mcp-publisher publish` (CLI + `server.json`) | npm + GitHub via package manifest | | **Glama** (`glama.ai`) | ~21k indexed | Auto-indexes from GitHub topics | GitHub topics + README | | **mcp.so** | ~19k indexed | Form + GitHub URL | README + package.json | | **PulseMCP** (`pulsemcp.com`) | ~12k indexed | Auto-syncs from Registry + GitHub | Registry + GitHub topics | | **awesome-mcp-servers** (GitHub list) | Hand-curated, ~1k entries | PR | Your README's first paragraph | | **MCPize Marketplace** | Curated, growing | Built into MCPize CLI | Your `mcpize.json` + README | | **Smithery** (`smithery.ai`) | ~7k curated | Form + GitHub URL (paid tier for featured) | README + manual edit |

Counts are approximate as of Q2 2026 and grow weekly, treat them as relative ranking, not exact figures.

**Strategy: publish to the Registry FIRST** (Step 7). Most other directories sync from it, so a single Registry submission propagates downstream within a day or two. Then submit to the four directories that don't auto-sync (Smithery, MCPize Marketplace, awesome-mcp-servers PR, plus a verification check that Glama / PulseMCP picked you up). The full sweep is one focused afternoon.

### Step 2: awesome-mcp-servers

Two relevant lists (forks fork forks):

- https://github.com/punkpeye/awesome-mcp-servers (most active)
- https://github.com/wong2/awesome-mcp-servers (older, large)

Submission is a PR adding one line to the appropriate category. The maintainer's review usually merges within 1-3 days.

```markdown
- [your-mcp-server](https://github.com/you/your-mcp-server), One-sentence description. Highlights what makes it different from the 5 closest siblings.
```

Two anti-patterns:

- **Marketing-speak** ("revolutionary AI-powered enterprise-grade ..."). Maintainers reject these.
- **Cluttering multiple categories**. Pick one. If you don't know which, ask in the PR comments.

The PR description should include: what your server does, who it's for, install command. Three lines max.

### Step 3: mcp.so submission

https://mcp.so/submit

Form fields (all required):

- GitHub URL
- Description (1-2 sentences, mirrors your README first paragraph)
- Tags (3-5 relevant, e.g. `database`, `claude`, `automation`)
- Category (pick the closest match)

After submission, mcp.so auto-pulls from your README:

- Project name + description
- Install snippet (looks for the first ` ```bash ` block with `claude mcp add`)
- Tools list (looks for `## Tools` heading + table)
- Demo screenshot (looks for the first `![](url)` image in README)

Optimization: if your README's first 200 chars are clear, your mcp.so listing looks great. If it's a wall of badges, it looks confused.

Indexing takes ~24 hours. Re-submission isn't necessary; mcp.so re-fetches your README weekly.

### Step 4: MCPize Marketplace

If you deployed via MCPize (Phase 8.1), your server is already in the MCPize Marketplace by default. Edit the listing in the MCPize dashboard:

- **Tagline**, one sentence, max 80 chars
- **Long description**, mirrors README, can be richer (markdown supported)
- **Featured tags**, 3-5 keywords
- **Pricing**. Free / Paid / Subscription (links to your /upgrade page)

Visibility in MCPize is curated, high-quality servers get featured, low-effort ones rank low. Curators look for: working demo, clean README, recent commits, reasonable response times on /health.

### Step 5: Smithery

https://smithery.ai

Form-based submission. Reviewer manually approves. Smithery has a paid tier ($X/mo) for "featured" placement, but the free listing is enough to get discovered.

Pulls from README + your repo's GitHub topics. Make sure you've added topics like `mcp`, `claude`, `model-context-protocol` on the GitHub repo (Settings → Topics).

### Step 6: Glama

https://glama.ai

Auto-indexes any GitHub repo with `mcp` in the topics + a `package.json` exposing an MCP-compatible server. No manual submission needed, just make sure your GitHub topics include `mcp` and `model-context-protocol`.

Pulls README + tags. Smaller audience, growing fast.

### Step 7: Official MCP Server Registry

The single highest-credibility placement is the **official MCP Server Registry** at `https://registry.modelcontextprotocol.io/`.

Note: the older `modelcontextprotocol/servers` GitHub repo no longer accepts new third-party server listings, its README explicitly redirects new submissions to the Registry. Don't waste a PR there.

The Registry is a machine-readable index that MCP clients (Claude Desktop, Cursor, Codex) consume programmatically. Listings are authored as a `server.json` in your repo and submitted via the official `mcp-publisher` CLI:

```bash
# Install the publisher CLI
npm install -g @modelcontextprotocol/publisher  # check the actual package name in the Registry docs

# Auth (one of OIDC via GitHub Actions, npm-package-owner verification, or DNS-TXT)
mcp-publisher login github

# Author server.json next to your package.json (minimal example)
cat > server.json <<EOF
{
  "name": "io.github.you/your-mcp-server",
  "description": "What it does in one sentence.",
  "repository": {
    "type": "git",
    "url": "https://github.com/you/your-mcp-server"
  },
  "version_detail": {
    "version": "1.0.0",
    "release_date": "2026-04-25"
  },
  "packages": [{
    "registry_name": "npm",
    "name": "your-mcp-server",
    "version": "1.0.0"
  }]
}
EOF

# Submit
mcp-publisher publish
```

After acceptance:

- Your server appears at `https://registry.modelcontextprotocol.io/v0/servers?search=your-server`.
- Downstream marketplaces (mcp.so, MCPize, Smithery, Glama) sync from the Registry, so a single Registry submission propagates everywhere.
- Updates: bump `version_detail.version` + re-publish. The Registry treats versions as immutable, published versions don't change retroactively.

Three things the Registry verifies before accepting:

- The package on npm matches the version in `server.json` (no drift).
- The repo URL resolves and points at the same package.
- Your authentication proves you own either the GitHub repo or the npm package.

**This one is worth doing first.** The downstream sync means one publish covers most of the marketplace ecosystem in Step 1.

Client check · run on your machine

cat package.json 2>/dev/null | python3 -c "import json,sys; p=json.load(sys.stdin); deps=list((p.get(\\"dependencies\\") or {}).keys()); print(\\"sdk:\\", \\"@modelcontextprotocol/sdk\\" in deps); print(\\"bin:\\", bool(p.get(\\"bin\\"))); print(\\"main:\\", bool(p.get(\\"main\\")))" 2>/dev/null || echo "no package.json in cwd"

**Expect:** sdk: True, plus either bin or main is True.

**If stuck:** Run \`npm init -y && npm install @modelcontextprotocol/sdk zod\`, then add \`"bin": { "your-server": "./dist/server.js" }\` to package.json.

### Step 8: How to spot directories not worth your time

The MCP space has ~30 directories. Most of them are scrapers that auto-add every npm package matching `mcp-*`. Indicators a directory isn't worth submitting to:

- **No editorial review**, every npm package shows up. Yours will too, no submission needed.
- **No clear submission process** (no form, no PR target), they're not actively curating.
- **Domain age \< 6 months + no GitHub traffic**, speculative listing site, no real audience.
- **"Submit your server, $99 for featured placement"**, paywalled marketplaces don't have organic traffic.
- **No about / no maintainer name**, automated scraper, no human discovery.

Stick to the six in Step 1. Anything else is bonus, not core.

### Step 9: Verify

Run `academy_validate_step`. The validator checks `package.json` is wired.

Manual end-to-end after submissions:

```bash
# 1. mcp.so listing exists
curl -s https://mcp.so/server/your-mcp-server | grep -o '<title>[^<]*'
# Should return your server's title

# 2. awesome-mcp-servers PR merged
gh pr list --repo punkpeye/awesome-mcp-servers --state merged --search "your-mcp-server"

# 3. Glama auto-index picked up
curl -s "https://glama.ai/api/mcp-servers?search=your-mcp-server"

# 4. MCPize listing reachable (only if deployed via MCPize)
curl -s https://mcpize.com/marketplace/your-mcp-server
```

Within a week of submission, all six should be active.

## Common traps

- **Submitting to scrapers + paid lists for "exposure"**, wastes time, attracts no real users.
- **Generic descriptions** ("MCP server for X"), mcp.so listings look identical. Differentiate.
- **Forgetting GitHub topics**. Glama can't auto-index without `mcp` topic on the repo.
- **PR to awesome-mcp-servers without the right category**, maintainer asks for changes, slows merge.
- **Re-submitting to same directory weekly**, annoying to maintainers, doesn't speed indexing.
- **Marketing-speak descriptions**, every directory's curators reject these on sight.

## What good looks like

Within 7 days of npm publish: mcp.so listed, awesome-mcp-servers PR merged, Glama auto-indexed, MCPize Marketplace edited, Smithery submitted, Anthropic official-list PR open. Discovery traffic starts within 2 weeks. After 60 days, ~30-50% of new installs come via these directories (the rest via direct README share, blog posts, social).

The work is one focused afternoon. The payoff is steady-state organic discovery for as long as your project is maintained.

[← GitHub OSS, trust signals that](https://studiomeyer.academy/recipes/9.2-github-oss) [Trusted publishing, token-less →](https://studiomeyer.academy/recipes/9.4-trusted-publishing)

Phase 9

npm publish, GitHub OSS, MCP marketplaces, trusted publishing

[Alle Phasen →](https://studiomeyer.academy/recipes)

Concepts

[MCPize](https://studiomeyer.academy/concepts/mcpize)

## Sitemap

Public pages of this site as Markdown: [sitemap](https://studiomeyer.academy/sitemap.md). Curated entry point: [llms.txt](https://studiomeyer.academy/llms.txt), full text: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).
