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 & teams

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.

Ways to integrate agent 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

Connect Conto to assistants and team 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 SDK, API, MCP server, CLI, or hosted flow that fits their agent, and move 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.

Receipt · rcpt_8c41settled
Helia Compute$1,920.00
Agent
procurement-agent
Category
compute
Policy
compute-spend-v3
Tx
0x9f2c…a8e1

Reconciliation

  1. Requested09:14:02
  2. Policy approved142ms09:14:02
  3. Executed onchain09:14:05
  4. Settled09:14:11
  5. Reconciled09:15:00

Demo

Build governed compute payments end to end

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 method that matches their runtime.

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