Developer Platform

Connect your agent to Conto and test its first payment in sandbox.

Start with a sandbox agent

1. Run the guided setup

npx @conto_finance/create-conto-agent

Creates an agent, wallet, policy, and API key for your first test payment.

2. Check your setup. Run npx @conto_finance/create-conto-agent doctor to check scopes and balance.
3. Make a test payment. Follow the generated example to see an approved, blocked, or review-needed result.

Payment request examples

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 request a payment. Conto checks it against your policy before anything is sent.

// 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_finance/create-conto-agent doctor
# first policy-checked payment
node example.mjs --execute

Conto Pay

No code, hosted

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

Pay @exa-api $10 for API usage

Held, checked against your rules, and sent from the agent's hosted wallet only after Conto clears it.

Five surfaces, one policy engine. Start in the sandbox (Tempo Testnet), then promote the same controls to production.

Ways to integrate agent payments

Add payment requests, spending checks, and approvals to your agent.

TypeScript SDK

Use typed helpers to configure agents, request payments, and check results.

MCP server

Connect Conto to assistants and team workflows through Model Context Protocol.

OpenAPI reference

Generate a client from the OpenAPI schema.

Machine-readable docs

Let agents find setup instructions through manifests, skills, and Markdown docs.

From sandbox setup to production

Step 1

Choose an integration path

Pick the surface that matches how your agent runs. Hosted Conto Pay needs nothing deployed.

Step 2

Create a test environment

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

Step 3

Prepare for production

Check your payment rules and records in sandbox before using them with real funds.

Demo

Test compute payments with spending limits

Test paid compute requests against a per-call limit and session budget using the SDK.

Providers polled

5 example quotes

Per-call cap

Session budget

$25

Run demo Browse demos

Test before using real funds

Developers can test agent payments without building their own spending controls.

Inspect approved, blocked, and review-needed requests before connecting real funds.

Payment examples

Micropayments

Budgets for paid API calls

Set spending limits per request and per session for API, inference, and compute usage.

Explore

Payout automation

Controls for agent payouts

Check agent payouts against spending limits and approval rules before sending.

Explore

Autonomous procurement

Payment controls for autonomous procurement

Agents select suppliers. Conto checks payments against your recipient rules, spending limits, and approval requirements.

Explore