Conto

Developer Platform

Integrate Conto through the SDK, REST API, MCP server, CLI quickstart, webhooks, OpenAPI, and machine-readable discovery endpoints.

First payment in a few lines

SDK

You own the runtime

Typed TypeScript helpers for request, approve, and execute.

import { Conto } from '@conto_finance/sdk';
 
const conto = new Conto({ apiKey });
const p = await conto.payments.request({
amount: 10, recipientAddress: '0x...', purpose: 'API usage',
});
// approved? execute it
if (p.status === 'APPROVED') await conto.payments.execute(p.requestId);

REST

Any language

One POST, bearer auth. Same policy check behind it.

curl -X POST https://conto.finance/api/sdk/payments/request \
-H "Authorization: Bearer $CONTO_API_KEY" \
-H "Content-Type: application/json" \
-d '{"amount":10,"recipientAddress":"0x...","purpose":"API usage"}'

MCP

Assistants & operators

Add the server, then your assistant can pay within policy.

// claude_desktop_config.json
{ "mcpServers": { "conto": {
"command": "npx",
"args": ["@conto_finance/mcp-server"],
"env": { "CONTO_API_KEY": "conto_agent_..." }
}}}
// then ask: "Pay api.exa.ai $10" -> calls pay

CLI

Terminal quickstart

Bootstrap an agent, wallet, policy, and key, then pay.

# agent + wallet + policy + key, one guided run
npx @conto_finance/create-conto-agent
# verify scopes, custody, and balance
npx conto doctor
# first policy-checked payment
npx tsx example.ts --execute

Conto Pay

No code, hosted

The hosted workspace. Ask the agent to pay, in plain language. The same policies, approvals, and record apply, with nothing to deploy.

Pay @exa-api $10 for API usage

Staged, policy-checked, and sent from your hosted wallet.

Five surfaces, one policy engine. Start sandboxed on Tempo Testnet, then promote the same controls to production.

Integration surfaces for agentic payments

Give builders the primitives they need to connect agent runtimes to governed payment workflows.

TypeScript SDK

Use typed helpers for setup, payment requests, policy checks, and agent-facing workflows.

MCP server

Expose Conto operations to assistants and operator workflows through Model Context Protocol.

OpenAPI reference

Build generated clients and contract-driven integrations against the public API schema.

Machine-readable docs

Use well-known manifests, skills, and LLM docs endpoints for agent discovery and retrieval.

How builders wire Conto into their agent runtime

Developers can start in sandbox, choose the integration surface that fits their agent, and promote the same controls toward production.

Step 1

Choose an integration path

Start with SDK, API, MCP, CLI, or hosted Conto Pay depending on how your agent runs.

Step 2

Bootstrap a sandbox

Create an agent, wallet, default policy, and key before sending the first test payment.

Step 3

Promote controls to production

Move from demo rails to production workflows while preserving policy and audit behavior.

Developer activity tied back to payment control

Teams can connect setup, test payments, API usage, and production readiness to the controls that will govern real spend.

Conto dashboard showing agent payment controls

See it in action

Compute & AI infra in action

A buyer agent negotiates compute across five providers over the SDK, checking session budgets and per-call caps before each paid request. The same governed-payment surface you build on.

Providers polled

5 live quotes

Per-call cap

$5

Session budget

$25

Ship faster on Conto

Developers can test payment controls without building the entire control plane first.

Teams can choose the integration surface that matches their runtime.

Docs, API contracts, and agent-readable endpoints stay discoverable.