API and MCP server

Point any MCP client at:

https://toolpin.dev/mcp

Streamable HTTP, stateless, no sign-up. Configuration differs between clients, but most take a shape like this:

{
  "mcpServers": {
    "toolpin": {
      "url": "https://toolpin.dev/mcp"
    }
  }
}

To raise your limits or use watch_server, add an API key as an Authorization: Bearer header. Never put a key in a URL.

How old the facts are.

Every reply carries as_of, the point at which all of our daily jobs had last succeeded, and stale when they have not run recently. We would rather tell you the data is old than quietly serve it as current.

The number that makes a count mean something.

Every per-server change count arrives with the catalog-wide drift rate beside it. Changes are heavily concentrated in servers nobody depends on, so "two changes in ninety days" tells you almost nothing until you know what a normal day looks like. This matters most when the reader is a language model, which will otherwise turn a bare number into a verdict we did not make.

Everything above answers a question about one server you already know about. The Feed API is the other shape: a cursored, catalog-wide stream of every recorded event, plus the full snapshot history behind any server.

• GET /v1/feed/events: new servers, tool-definition changes, endpoints going down and coming back. Resume from a cursor and you get every later event exactly once.
• GET /v1/snapshots?server=: every capture of that server's tools we still hold, with hashes and optionally the definitions.
• The feed reports its own retention window and tells you when a gap sits behind your cursor, so a consumer that has been away can tell it missed something instead of resuming as though it had not.

Built for the gateways, registries, and platforms rebuilding this dataset internally. Priced by contract rather than from this page, because the shape depends on what you are doing with it.

Email us about the feed

There is no Toolpin SDK, on purpose. Every read is a GET with one header, and /openapi.json describes every response, so a typed client in your language is one generator run away and will never be a version behind ours.

The one piece worth copying is the feed loop. Resume from the cursor, and check whether retention removed anything behind you:

let cursor = loadCursor();          // whatever you persisted last run

while (true) {
  const url = new URL("https://toolpin.dev/v1/feed/events");
  url.searchParams.set("limit", "500");
  if (cursor !== null) url.searchParams.set("cursor", String(cursor));

  const res = await fetch(url, { headers: { Authorization: `Bearer ${KEY}` } });
  if (res.status === 429) { await sleep(60_000); continue; }   // burst limit
  if (!res.ok) throw new Error(await res.text());

  const { data } = await res.json();

  // Retention is 180 days. If you were away longer, say so loudly rather than
  // resuming as though nothing was missed.
  if (data.retention.gap_before_cursor) {
    console.warn("gap: events were pruned between your cursor and", data.retention.oldest_event_id);
  }

  for (const event of data.events) handle(event);

  cursor = data.next_cursor;   // unchanged on an empty page, so this is safe
  saveCursor(cursor);
  if (!data.has_more) break;   // caught up; poll again later
}