What We Learned Listing 5 MCP Tools
in One Day

teai.io's MCP gateway has a paid tool store (80% developer revenue share) where third-party developers can list their own MCP servers and get paid per call. As the team that built it, we became our own first sellers and listed 5 tools in a single day. This post is that first-hand, measured record. No numbers are inflated.

curl -X POST https://api.teai.io/api/v1/mcp/services \
  -H "Authorization: Bearer $TEAI_API_KEY" -H 'Content-Type: application/json' \
  -d '{"slug":"yourtool","upstream_url":"https://yourtool.example.com/mcp","default_credits":5}'

The 5 tools we listed (all billing E2E-tested in production)

The single biggest finding — agents choose by description and price alone

When your buyer is an AI agent, SEO, branding, and ads do nothing. All an agent reads is the tools/list description and price. That means the accuracy of your description is your entire marketing. The format we apply to every tool:

Line 1: "Give it X, it returns Y" — be concrete
Input: meaning, units, limits, and defaults for every parameter (with examples)
Output: format and rough size
Measured latency: "about N seconds, measured" (always time it 3x yourself)
What it can't do: be honest about limits (no OCR, no live-database lookup, etc.)

Writing "what it can't do" looks like it costs you calls, but it's the opposite. An agent that gets burned by a tool that doesn't match its description never calls it again. Our trademark-risk tool, for instance, explicitly states it does not cross-check against Japan's live trademark registry.

How we priced them (real examples and the real revenue split)

The split rounds up ((price×80+99)/100), so a low-priced tool at 3cr keeps effectively 100% for the developer (3cr in → 3cr to the developer). Third-party tools are capped at 60cr/call.

Minimum implementation is ~100 lines (Cloudflare Workers)

All you need is a single JSON-RPC 2.0 POST handler. Three methods are required.

(notifications/* just needs a 202.) Registering is one API call:

# 1. Deploy your Worker first, then register (registration does a live tools/list check)
curl -X POST https://api.teai.io/api/v1/mcp/services \
  -H "Authorization: Bearer $TEAI_API_KEY" -H 'Content-Type: application/json' \
  -d '{"slug":"yourtool","upstream_url":"https://yourtool.example.workers.dev","default_credits":5}'

# 2. Once approved (pending → live), check earnings any time
curl https://api.teai.io/api/v1/mcp/earnings -H "Authorization: Bearer $TEAI_API_KEY"

Gotchas we actually hit (for the next person listing)

• Upstream response cap is 5MB — we base64-double-encoded a font-embedded PDF (4.2MB) and blew past it. Fix: emit binary once, and subset-embed fonts (4.2MB → 35KB).
• Slugs need 3+ characters ("qr" got rejected, so we used "qrcode")
• The first 20–30s after deploy can 5xx from edge propagation lag — confirm 5 consecutive 200s before registering
• Verify billing against the ledger (/api/v1/mcp/earnings), not your balance — balance mixes in other usage
• Return a JSON-RPC error for input errors and the caller isn't charged — the gateway inspects the response and skips billing on errors. Writing real validation builds trust with callers.
• Measure latency for real, not by feel from curl — TLS handshake overhead makes naive curl timing look worse than it is

🎙 Listen to the summary

Building with an AI coding agent? Paste this prompt

Not sure what to build yet? Paste the following into Claude Code (or any coding agent) and it will take you from a working scaffold, through deployment, right up to registering on teai.io. This is genuinely how we built and shipped all 5 of our own tools.

Build a minimal MCP server to list on the teai.io MCP tool store. Requirements:
- Cloudflare Workers (TypeScript). One JSON-RPC 2.0 POST handler
- Implement: initialize / tools/list / tools/call (return 202 for any other method)
- What the tool does: "<describe in one line, e.g. take a PDF URL and return one page as an image>"
- In the tools/list description, be honest about: the meaning/units/limits/defaults of every input,
  the output format, measured latency (time it 3x yourself), and what it can't do
- Output must be {content:[{type:"text"|"image"|"resource", ...}]}, under 5MB
- Once built, run wrangler deploy and confirm the production URL returns 5 consecutive 200s
- Finally, fill in slug / upstream_url / default_credits and run this curl to register on teai.io
  (TEAI_API_KEY comes from an environment variable):

curl -X POST https://api.teai.io/api/v1/mcp/services \
  -H "Authorization: Bearer $TEAI_API_KEY" -H 'Content-Type: application/json' \
  -d '{"slug":"???","upstream_url":"https://???.workers.dev","default_credits":?}'

Ideas nobody has listed yet (unverified hypotheses — might be profitable)

We haven't measured real agent demand for these yet, so consider these hypotheses about what might do well, not guarantees. They should at least share the traits our 5 tools above have in common: lightweight, low latency, and an honest description.

• Image conversion — HEIC→JPEG, background removal, transparent PNG. Agents need this constantly whenever they share generated output
• Markdown/HTML → PDF — meeting notes, invoices, simple contracts — anywhere an agent wants to end a task by "producing a document"
• Regional government-data lookups — postal-code→address, business-registry lookups, tax-ID format checks — unglamorous, but rarely built as a standalone tool
• Price/stock monitoring — watch a URL and report when the price or availability changes (a thin wrapper around polling)
• Domain/DNS diagnostics — whois, DNS propagation checks, SSL expiry checks (we got burned by exactly this ourselves — bim.house went fully down from an expired cert)
• Contract/terms red-flag checks — adjacent to our own trademark-risk tool (shohyo). A category where being explicit about limits earns extra trust

Want to list your own tool?

Everything above is the full path from implementation to listing (we also have a Worker template). We'll pair directly with the first few developers through implementation and listing. Get a free API key at /keys.