New12 ready-made connectors — MCP, REST, and plugins

Ready-made connectors for your agent. You point at the docs — we deliver.

OAuth, API key, bearer — any auth. Point us at the official documentation; we extract, generate the manifest, validate, and publish. Ready to consume via MCP, REST, or plugin.

No credit card. Hello world in 30 seconds.

Personal mode

I want to connect my APIs to my Claude/Cursor

  1. Install the plugin in Claude Code or Cursor.
  2. Run /connector-platform add followed by the service.
  3. Log in once. The tools show up in your chat.
$ claude /connector-platform add github
Personal modeYou just pass the name or URL of the service — the rest is automatic.
Multi-tenant mode

I want to offer integrations to my SaaS users

  1. Point at the docs URL of the connector you want to expose.
  2. Start a connect-session from your backend.
  3. Your users see “Connect X” — your brand, your domain.
$ curl -X POST api.cp.dev/connect-session
Multi-tenant modeWhitelabel + per-end-user Postgres RLS.
BuilderConsumer
// how it works

Three steps. You point at the docs. We publish.

Generic by design: works for both Personal and Multi-tenant modes. What changes is where the token lives — you never touch YAML, OpenAPI specs, or JSONata.

01 — Point

You pass the URL of the official documentation

Our docs reader extracts the API, the AI generates the YAML manifest, automated validations run (reachability, schema, critic), and our team reviews before publishing. You consume — you don't write adapters.

02 — Authorize

OAuth solved for you, on our infra

Refresh, revocation, per-tool scopes, per-user isolation. You'll never write “store the refresh token securely” again.

03 — Consume

One connector, three surfaces

MCP server, REST API, and plugins (Claude Code, Cursor, or the agent you build) — all pointing at the same audit log. The client changes — the contract doesn't.

// what matters

Defensible where it matters. Invisible where it doesn't.

Three pillars where we make a real difference, three where we disappear behind your product.

Your OAuth, your keys

BYO OAuth: register your own app on GitHub/Slack/etc — your users authorize your name, not ours. Client secret never touches the browser.

Row-level isolation in Postgres

Postgres RLS by user_id + tenant_id. One client's token never sees another's data — not by convention, by database policy.

Native audit log

Every tool call is logged with request_id, effective OAuth scope, and end user. Exportable to Datadog/Splunk via webhook.

Three surfaces, one connector

MCP server, REST API, and IDE/agent plugins (Claude Code, Cursor, or your own) all come from the same published connector. You don't pick — you expose all three and let the client decide.

Single cpt_* token

Same bearer for everything. Per-scope rotation, configurable expiry, instant revoke via API or dashboard.

Full whitelabel

Consent screen on your domain, with your logo and your colors. Your users never see our wordmark — unless you want them to.

// three surfaces

Same authorization, same audit log.

The client changes — the contract doesn't. cpt_* token works in all three.

# You point at the official docs — we extract, generate the manifest, validate, and publish.
$ curl -X POST https://api.connector-platform.dev/v1/connectors/request \
    -H "Authorization: Bearer cpt_live_8f3c…a91" \
    -d '{"docs_url": "https://docs.github.com/rest", "slug": "github", "category": "vcs"}'

{
  "status":           "queued",
  "estimated_review": "2–4 business days",
  "request_id":       "req_01HZ9F…"
}
# You don't write YAML, OpenAPI specs, or JSONata. You get the connector ready to use.
// who's already using it

Early traction, real numbers.

1.2M+
tool calls processed in private beta, 12 live connectors, P95 of 180ms.
GitHub1.4k starsP95 180ms12 connectors
Off our tech-debt list. In 2 days we replaced 3 homegrown OAuth integrations with Connector Platform — kept the audit log compatible with our SOC.
Pedro Mendes — Platform, BR fintech (Series A)
Private beta, Apr/2026

// stats and quote: placeholders, to be wired up with real data before GA.

// pricing

Transparent. Per execution. No seat tax.

You pay per tool call that reaches the upstream. OAuth handshakes, internal retries, and the audit log are on us.

Starting at
$2/ 1k executions

GA in Jul/2026. Private beta is free until then. Volume > 1M executions/month: custom pricing.

  • 12 OAuth connectors included
  • MCP, REST, and Claude Code plugin — no upcharge
  • Audit log + webhook export included
  • Whitelabel + custom OAuth apps on the Team plan
  • Beta caps at 50k executions/month per account. No credit card.
// common questions

Questions we've already heard three times.

You can. Then you also write refresh-token logic, token rotation, per-tool scopes, Postgres RLS, audit log, and three adapters (MCP/REST/plugin). We already did. cpt_* is a bearer; swap yours for it and move on.
Two levels. (1) Revoke the cpt_* via API or dashboard — invalidates all token sessions, P95 propagation 200ms. (2) Per-end-user revoke: DELETE /v1/connections/:user_id/:provider — kills the upstream refresh token and clears the rows under RLS.
Manifests are versioned. When the upstream changes, we publish github@v3 alongside github@v2. You migrate when you want; the old version keeps answering until the deprecation window closes (90 days minimum).
Composio focuses on tools for the individual agent; Arcade is similar with an MCP-first lean; Pipedream Connect is a workflow engine + connect. We're the only one that delivers MCP + REST + Claude Code plugin simultaneously, with real Postgres RLS and a unified cpt_*. If you just need tool-calling for your agent, Composio works. If you need to expose integrations to your customers in a multi-tenant SaaS, that's our sweet spot.
Import your existing refresh tokens via POST /v1/connections/import (CSV or stream). We rewrite the rows under RLS, test a real refresh on each one, and return a report of the ones that failed. Your users don't re-log. Average migration time: 2 to 5 days.
Enterprise plan: Docker + Postgres in your cloud, control plane in ours. Available post-GA. During beta, everyone runs on our infra (us-east-1, sa-east-1).

Thirty seconds to hello world. Thirty minutes to multi-tenant.

Private beta, no credit card. You walk away with a cpt_* token and twelve ready-made connectors.

// founded by someone who's hand-rolled OAuth one too many times — 17 years building software