APIKumo gives every API collection an automatic MCP endpoint — here's why that matters

eknut w. — Mon, 11 May 2026 09:07:18 +0000

MCP (Model Context Protocol) is quickly becoming the standard way AI agents interact with external tools and services. Claude, Cursor, Continue, and others all speak MCP natively now.

The problem? Setting up an MCP server for your API used to mean writing a separate server, maintaining it alongside your actual API, and keeping it in sync whenever your schema changed.

APIKumo removes that entirely.

Every collection you build and publish in APIKumo gets an automatic MCP endpoint — no configuration, no separate server, no code to maintain.

How it works in APIKumo

When you publish a collection in APIKumo, you get three things out of the box:

A public doc page — with version selector, scroll-spy nav, changelog, and a live try-it console
AI chat grounded in your endpoints — users can ask questions about your API and get answers based on your actual definition, not hallucinated responses
An MCP endpoint — a live Model Context Protocol endpoint that any MCP-compatible AI agent can connect to immediately

The MCP endpoint is generated directly from your collection. That means it stays accurate by default — if you update a request in APIKumo, the MCP endpoint reflects it automatically.

What this looks like in practice

Say you've built a collection for a weather API in APIKumo. Once published, any AI agent that supports MCP can:

Discover your endpoints (GET /forecast, GET /current, etc.)
Understand the parameters, response shapes, and authentication requirements
Call the API natively — no custom tool definitions, no prompt engineering

Your API becomes an AI-native service the moment you publish it.

This is what "AI-ready docs" actually means — not just a page that looks good, but a surface that AI agents can read and act on.

Why this is a big deal for API developers

Most APIs are invisible to AI agents today. They exist as REST endpoints that humans know about, but agents can't discover or use without a human writing a wrapper.

With APIKumo's automatic MCP endpoint:

No MCP server to build or maintain — it's generated from your collection
No drift — your docs, AI chat, and MCP endpoint all come from the same source of truth
Works immediately — publish a collection, share the MCP endpoint URL, done

Try it

APIKumo is free while in preview.

Build your collection, publish it, and you'll see the MCP endpoint URL right in your dashboard — ready to drop into Claude, Cursor, or any MCP-compatible client.

APIKumo · Build, automate, and publish your API

Design requests, automate auth, version, and publish typed docs with AI chat and MCP built in.

apikumo.com

What APIs are you working with that you'd want to expose as MCP endpoints? Drop it in the comments.

I built an API workspace where docs write themselves — with AI chat and MCP built in

eknut w. — Sun, 10 May 2026 04:09:40 +0000

Most developers I know use at least three tools for a single API.

Postman or Insomnia for sending requests. Notion or a static site for
documentation. And some custom script — or a lot of manual copy-pasting
— for handling auth like HMAC signatures or chained tokens.

None of them stay in sync. The docs go stale. The auth scripts break.
And every new teammate has to figure out the whole setup from scratch.

That's why I built APIKumo.

What it is

APIKumo is an API workspace that covers the full lifecycle in one place:

Request builder — Monaco-powered editor, collections, environments, multi-tab, 20+ code generation targets
Pre/Post processors — automate auth before requests fire. HMAC signing, bearer token from env, JSONPath extraction, variable chaining, response assertions. No external scripts.
Doc publishing — publish to your own subdomain with version selector, changelog, scroll-spy navigation, and a live try-it console

The part I'm most proud of: Docs

API documentation has a reliability problem. You write it once,
it drifts from the actual implementation, and nobody trusts it after a month.

APIKumo generates docs directly from your requests and schemas —
so they stay accurate by default, not by discipline.

Every published collection also gets:

AI chat grounded in your real endpoints
Users can ask questions inside your doc page and get answers based on
your actual API definition. Not hallucinated. Not generic.

Automatic MCP endpoint
Every collection exposes a Model Context Protocol endpoint with zero
configuration. Claude, Cursor, Continue — any MCP-compatible AI agent
can read your API surface and call it natively.

The goal: docs shouldn't be a static page you maintain by hand.
They should be a living surface that works for both humans and AI agents.

Where it stands

APIKumo is free while in preview. I'm actively building and would
genuinely love feedback — especially from developers who've felt this
pain before.

👉 apikumo.com

Also launched on Product Hunt today if you want to support or leave feedback there.

What's the biggest pain point you've had with API tooling?
Would love to hear in the comments.

Forem: APIKumo