Developers

The same nineteen actions.Over a plain API.

Everything Plutus can do, your code can do, because they call the same registry. REST when you want to write it yourself, MCP when your agent should drive, and one set of scopes and gates governing both.

Get an API keySee the agent side

Quickstart

Three steps, none of them a meeting.

No sales call to get a key, no sandbox application form. Sign up, open the developer console, and the first request works the same afternoon.

01

Create a scoped key

The developer console in settings issues keys with only the scopes you pick. A key that reads documents cannot send them, and a key that sends cannot touch webhooks.

02

Make the call

Plain REST with bearer auth, a workspace header, and an idempotency key on every write, so a retry can never quietly become a second document.

03

Hear back

Webhooks cover the whole lifecycle, from created through viewed, signed, completed, declined, and voided. Your system finds out when the humans do.

The REST surface

Boring on purpose.

JSON in, JSON out, bearer tokens, predictable nouns. Create documents, fill their placeholders, send them, and follow what happens next. Embedded signing sessions let you put the signing step inside your own product instead of sending people away from it.

Scopes on every key

workspaces:readdocuments:readdocuments:writedocuments:sendwebhooks:readwebhooks:writesigning_sessions:write

Webhooks for the whole lifecycle

document.createddocument.sentdocument.vieweddocument.signeddocument.completeddocument.declineddocument.voided

Every action is documented with its parameters, its scope, its rate limit weight, and a worked example, in the developer console inside your account.

Create a documentREST
POST /api/v1/documents
Authorization: Bearer pk_live_...
X-Plutus-Workspace-Id: <workspace id>
Idempotency-Key: <uuid>

{
  "title": "Acme service agreement",
  "variables": {
    "client_name": "Acme Inc.",
    "total": "12,000"
  }
}

Or skip the SDK entirely

Let the agent write the integration.

If the code you were about to write is glue between a model and our API, the MCP server already is that glue. Point a client at the endpoint, approve it on the consent screen, and the actions show up as tools it can call under scopes you granted.

Connections start with read scopes only, write access is requested when an action needs it, and everything an agent does lands in the same audit trail as your own clicks.

Connect a clientMCP
{
  "mcpServers": {
    "plutusdoc": {
      "type": "http",
      "url": "https://app.plutusdoc.com/api/mcp"
    }
  }
}

The client discovers the authorization server on its own, sends you to a consent screen, and comes back holding a token scoped to exactly what you agreed to.

The first request is minutes away.

Create an account, open the developer console in settings, and issue a key with exactly the scopes your integration needs. The trial includes the full API, and so does every plan after it.

Start freeRead how it is governed