MCPize: Publish Your MCP Server

Part of the MCPize suite (https://mcpize.com) — from idea to published MCP server.

Previous:

/mcpize:idea

(discover & validate) →

/mcpize:build

(build & test) This skill: Publish to marketplace + Go-to-Market

Take a built MCP server and publish it to the MCPize marketplace — SEO, pricing, logo, listing, social media posts, all in one flow.

The person using this might have just finished

/mcpize:build

Reference files

Before starting, read these reference files for details:

• ${CLAUDE_SKILL_DIR}/references/quality-checklist.md

  — 16 quality checks the dashboard uses (C1-C5, I1-I6, N1-N5) and what

  --auto

  handles

• ${CLAUDE_SKILL_DIR}/references/social-templates.md

  — ready-to-fill templates for Twitter, Reddit, LinkedIn, HN, Discord, README badges

The Job

0. Locate project & parse context — find the server and its brief
1. Quality gate — make sure it's ready (skip if

   /mcpize:build

   already verified)
2. Deploy — get it on MCPize Cloud (skip if already deployed)
3. Publish — SEO + pricing + logo + marketplace listing via

   mcpize publish --auto

4. Go-to-Market + verify — social posts, README updates, launch checklist, live verification

Step 0: Locate Project & Parse Context

Find the server

Look for

mcpize.yaml

If multiple candidates or none found, use

AskUserQuestion

• header: "Which project should I publish?"
• subheader: "I need to find your MCP server project"
• Provide options or ask for a path

Find the brief

Look for

mcp-brief-*.md

• Pricing model → determines

  --free

  vs

  --pricing "..."

• Server description → enriches SEO generation
• Tool list → for social media content
• Target audience → for marketing copy

If no brief exists, extract context from:

1. README.md

   — description, tools, features

2. package.json

   /

   pyproject.toml

   — name, description

3. mcpize.yaml

   — runtime, secrets
4. Source code — tool names and descriptions from MCP registration

Extract requirements

Build a mental model:

• Server name (from mcpize.yaml, package.json, or directory name)
• Description (from brief or README)
• Tools list (from brief or source code)
• Pricing model (from brief: "Free", "Freemium", "Paid")
• Runtime (TypeScript or Python — from mcpize.yaml)
• Required secrets (from mcpize.yaml

  secrets:

  section)

Step 1: Pre-Publish Quality Gate

Skip logic (IMPORTANT)

If

/mcpize:build

1. Run

   mcpize whoami

   — if fails, tell user to run

   mcpize login

   and wait
2. Then note: "Quality checks already passed during

   /mcpize:build

   — skipping to deploy."

Only run checks if:

• No build history in this conversation
• User built the server manually
• User explicitly asks to re-verify

Checks to run (when needed)

Run these in order. Stop on first blocker failure.

mcpize whoami

npm test

pytest

npm run test:smoke

bash test-mcp.sh

mcpize doctor

src/

sk-

api_key.*=

If a blocker fails:

1. Show the error clearly
2. Suggest the fix
3. Help implement the fix
4. Re-run the check
5. Continue only when it passes

Login failure: If

mcpize whoami

mcpize login

mcpize whoami

Step 2: Deploy (if needed)

Check current deployment status

First, check if

.mcpize/project.json

mcpize status

If

.mcpize/project.json

mcpize status

If the server is already deployed and healthy → skip this step:

"Server already deployed and healthy — skipping deploy."

Deploy to MCPize Cloud

This is an irreversible action. Follow the protocol:

1. State WHY: "Deploying creates a live endpoint on MCPize Cloud that users can connect to. This makes your server accessible via

   https://{name}.mcpize.run

   ."

2. Tell user what will happen:

   • Code will be uploaded and built in the cloud
   • A live endpoint will be created
   • Health monitoring will start

3. Warn the user: "Deploy takes 3-5 minutes — your code gets uploaded, built in the cloud, and a live endpoint is created. Grab a coffee."

   Then share a wisdom quote about patience. Pick one that fits the moment — something original, not overused. Examples:

   • "The two most powerful warriors are patience and time." — Leo Tolstoy
   • "Nature does not hurry, yet everything is accomplished." — Lao Tzu
   • "Have patience. All things are difficult before they become easy." — Saadi

4. Run deploy (with

   --skip-wizard

   to control publish separately):

mcpize deploy --skip-wizard --yes

Note: Deploy creates the server with default "free" status — this is expected. The server is NOT visible on the marketplace yet (deploy = infrastructure only, publish = marketplace listing). Pricing gets set correctly in Step 3 during

mcpize publish

. Tell the user: "Don't worry about the 'free' status — that's just a deploy default. We'll set up real pricing in the next step."

4. Verify deployment:

mcpize status

Confirm the status shows "ready" or "healthy".

5. If deploy fails: Run

   mcpize diagnose

   and help debug.

Step 3: Publish to Marketplace

Determine pricing from brief

Read the brief's Monetization section:

• If "Free" explicitly stated → use

  --auto

  (defaults to free)
• If no pricing mentioned → default to freemium (matches

  /mcpize:idea

  default assumption). Use

  --auto --pricing "Free: 50 requests/day. Pro $9.99/mo: 1000 requests/day"

• If "Freemium" or "Paid" → use

  --auto --pricing "description from brief"

CRITICAL — MCPize billing constraints (do NOT invent features that don't exist):

MCPize supports exactly 3 plan types:

fixed

usage

hybrid

Quotas are per-request and per-token only. Rate limits are per second/minute/hour/day.

DO NOT generate pricing with:

• ❌ Seats / per-user pricing (MCPize bills per API request, not per user)
• ❌ "Team" or "Enterprise" tiers with seats, SSO, HIPAA, BAA, SLA
• ❌ "Contact sales" / "Custom pricing" options
• ❌ Feature gating by tool name (all tools are available on all plans)
• ❌ Any capability MCPize doesn't actually support

Valid pricing patterns:

# Freemium
"Free: 50 requests/day. Pro $9.99/mo: 1000 requests/day"

# Usage-based
"Pay per use: $0.01 per request, first 100 free"

# Hybrid
"Starter $9.99/mo: 500 requests/day. Pro $29/mo: 2000 requests/day, $0.005/req overage"

Rules:

• Maximum 1 free plan (price_monthly: 0)
• Paid plans must have price_monthly > 0
• Unlimited quota only if price >= $50/mo OR usage/hybrid type with usage_price > 0
• Differentiate plans by request quotas, rate limits, and token limits — not by features or seats

Preview first (optional but recommended)

mcpize publish --dry-run --auto
# or
mcpize publish --dry-run --auto --pricing "Free: 50 requests/day. Pro $9.99/mo: 1000 requests/day"

Show the user what will happen before executing.

Run publish

For free servers:

mcpize publish --auto

For paid servers:

mcpize publish --auto --pricing "{pricing description from brief}"

This single command does:

1. Clean server name via AI (e.g., "fda-drug-info-mcp" → "FDA Drug Info")
2. Generate SEO content (display name, category, tags, descriptions) via AI
3. Set up pricing (free or AI-generated tiers)
4. Generate logo via AI (OpenAI gpt-image-1)
5. Publish to MCPize marketplace

If publish fails with "Failed to update server status" but name/SEO/pricing/logo all succeeded — check

mcpize status

active

mcpize publish --show

Verify publish

mcpize publish --show

Confirm SEO content is configured and pricing is set.

Step 4: Go-to-Market + Verification

4a: Generate viral-pattern social posts

Use templates from

${CLAUDE_SKILL_DIR}/references/social-templates.md

Twitter/X — viral pattern (CRITICAL)

1. Pick the right variant (A/B/C) from social-templates.md based on the server's story:

   • Variant A (Builder's confession) — niche/contrarian servers, vulnerability angle
   • Variant B (Eat your own cooking) — when user is also the tool/skill author (strongest trust signal)
   • Variant C (Specific number flex) — when there are concrete metrics (tool count, time, data points)

2. Fill placeholders with actual server data:

   {server_name}

   ,

   {slug}

   ,

   {one_liner}

   ,

   {tool_count}

   ,

   {key_benefit}

   , etc.

3. Generate a Twitter Intent URL so the user clicks once to publish:

   • Take the chosen variant's main tweet body (NOT the reply — the marketplace link goes in a separate reply to avoid the -30-50% reach penalty for external links)
   • URL-encode: spaces →

     %20

     , newlines →

     %0A%0A

     ,

     @

     →

     %40

     ,

     :

     →

     %3A

     ,

     /

     →

     %2F

     ,

     '

     →

     %27

     ,

     +

     →

     %2B

     ,

     —

     →

     %E2%80%94

   • Format:

     https://twitter.com/intent/tweet?text={encoded_text}

4. Present to the user as a clickable markdown link plus the reply text separately so they can copy-paste it after the main tweet goes live.

Output format (show this to the user):

🐦 Your viral tweet is ready (variant B — builder/creator angle)

Main tweet:
─────────────────
built fda-drug-info to query 50k+ drug labels in one call

then used it to debug my mom's prescription interactions

found 2 issues her pharmacist missed

it's open source btw
─────────────────

[📤 Click to publish on X](https://twitter.com/intent/tweet?text=built%20fda-drug-info%20to%20query%2050k%2B...)

After posting, reply to your own tweet with:
─────────────────
grab it → mcpize.com/mcp/fda-drug-info

taking requests for the next build
─────────────────

Why this works:
• Vulnerability + specific numbers (50k+, 2 issues) → high dwell time
• Link in REPLY not main tweet → avoids -30-50% reach penalty
• Question CTA in reply → triggers replies (13.5x algo weight)

Other platforms (Reddit, LinkedIn, HN, Discord) — generate using their respective templates from social-templates.md. These don't penalize links the way X does, so links stay in body. Tone still casual builder voice — no "Excited to share!" corporate openers.

4b: Update README with MCPize badges and install snippets

Use the templates from

${CLAUDE_SKILL_DIR}/references/social-templates.md

1. MCPize badge — shields.io badge linking to marketplace page
2. Connect section —

   npx -y mcpize connect @{username}/{slug} --client claude

3. Per-client install commands — Claude, Cursor, Windsurf, Cline CLI commands
4. JSON config — for manual setup

Get the endpoint URL from

mcpize status

4c: Generate launch checklist

Create

LAUNCH-CHECKLIST.md

# Launch Checklist: {Server Name}

## Pre-Launch
- [x] Server deployed and healthy
- [x] Marketplace listing published
- [x] SEO metadata configured
- [x] Pricing set
- [x] Logo generated
- [ ] README updated with MCPize badge + install snippets
- [ ] GitHub repo public (if applicable)

## Launch Day
- [ ] Twitter/X thread posted
- [ ] Reddit r/mcp post published
- [ ] Discord communities notified
- [ ] LinkedIn post shared

## Week 1
- [ ] Hacker News "Show HN" posted
- [ ] Monitor MCPize dashboard for first subscribers
- [ ] Check `mcpize logs` for errors
- [ ] Respond to user feedback

## Week 2-4
- [ ] Dev.to / Hashnode tutorial published
- [ ] Add features based on usage patterns
- [ ] Consider blog post about building it

4d: Verification loop ("Ralph loop")

Verify the published server works end-to-end:

1. Deployment health:

mcpize status

Confirm status is healthy.

2. MCP protocol test to live endpoint (hosted servers require auth):

# Get auth token and endpoint URL
TOKEN=$(python3 -c "import json; print(json.load(open('$HOME/.mcpize/config.json'))['token'])")

# Health check (no auth needed)
curl -s {endpoint}/health

# MCP initialize (auth required)
curl -s {endpoint}/mcp \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"verify","version":"1.0.0"}}}'

3. Tools verification:

curl -s {endpoint}/mcp \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

Confirm all expected tools are listed.

4. Error log check:

mcpize logs --severity ERROR

Should return no recent errors.

5. If any check fails:
   • Diagnose the issue (

     mcpize diagnose

     or manual investigation)
   • Fix the problem
   • Re-deploy if code changes were needed:

     mcpize deploy --skip-wizard --yes

   • Re-run verification from step 1
   • Only proceed when ALL checks pass

4e: Final handoff

Present the summary:

Published! Your MCP server is live.

Server:   {name}
Listing:  https://mcpize.com/mcp/{slug}
Endpoint: {endpoint-url}
Tools:    {count} tools
Pricing:  Free / ${price}/mo

What's done:
  [x] Deployed to MCPize Cloud
  [x] SEO metadata generated and saved
  [x] Logo generated
  [x] Pricing configured
  [x] Published to marketplace
  [x] Verified — all tools responding

Next steps:
  1. Review your listing: https://mcpize.com/mcp/{slug}
  2. Upload a custom logo if you want (dashboard > General tab)
  3. Post the social media content below
  4. Follow the LAUNCH-CHECKLIST.md

Social media posts:
  [Include all generated posts for easy copy-paste]

Tone & Communication Style

Talk like a friendly California dev who's genuinely stoked to help ship something. Examples:

• After deploy succeeds: "Nice, deploy went clean! Server's live and healthy."
• Before publish: "Alright, let's get this on the marketplace. Here's what's about to happen..."
• After everything's done: "Boom, you're live! Your server is on the marketplace and ready for users."
• On errors: "Hmm, that didn't go as planned. Let me dig into this..." (stay calm, debug, fix)

Don't overdo it — keep it professional but warm. No forced enthusiasm, just genuine helpfulness.

Important Notes

• Never publish without user awareness — always show

  --dry-run

  first or clearly state what will happen
• Deploy and publish are separate actions — deploy puts code in the cloud, publish makes the listing visible on the marketplace
• Logo generation uses OpenAI — it costs money on the platform side. If it fails (rate limit, payment issue), continue without logo and note it can be added later in the dashboard
• Social media content is generated, not posted — the user decides when and where to post
• This should feel like a launch party, not a chore — celebrate the achievement!