Quickstart

End-to-end setup on Tempo Testnet. By the end you’ll have a Conto organization, an AI agent, a funded testnet wallet, two test policies, and a verified onchain payment. Total time: about 10 minutes. No real funds required.

What you’ll build

Why Tempo Testnet?

Tempo Testnet pays transaction fees in pathUSD itself, so you don’t need a separate gas token. Combined with free faucet funds, it’s the fastest way to test the full flow.

Property	Value
Network	Tempo Testnet
Chain ID	`42431`
Currency	`pathUSD` (TIP-20)
Gas	Paid in `pathUSD`. No separate gas token.
Explorer	`explore.moderato.tempo.xyz`

Prefer the command line? The CLI quickstart wraps every step below into one interactive command:

npx @conto_finance/create-conto-agent

Choose Your Key Up Front

Most developers need both of these at different points in the integration:

Use case	Credential	Env var
Create agents, link wallets, assign policies, or repair ownership from your backend	Organization API key (`conto_...`)	`CONTO_ORG_API_KEY`
Let the agent call `/api/sdk/*` payment and read endpoints	Agent SDK key (`conto_agent_...`)	`CONTO_API_KEY`

If your app provisions agents for end users, create the agent with an org API key first, then hand the agent its own SDK key for runtime payment calls.

Step 1. Create your account

Visit conto.finance and sign up with email or Google OAuth.
Create your organization. This is the top-level container for agents, wallets, and policies.

Step 2. Create and fund a wallet

Create the wallet

Sidebar > Wallets > Create Wallet.

Field	Value
Name	`Test Operations Wallet`
Custody Type	`PRIVY` (recommended)
Chain Type	`EVM`
Chain	Tempo Testnet (`42431`)

Provision onchain

Click Provision. Conto assigns an onchain address on Tempo Testnet.

Fund with the faucet

On the wallet detail page, click Faucet. Free testnet pathUSD arrives in seconds.

For other custody options (SPONGE, EXTERNAL, SMART_CONTRACT), see Custody modes.

Step 3. Connect an agent

Open Agents

Sidebar > Agents > Connect Agent.

Fill in details

Field	Example
Name	`Test Payment Agent`
Type	`CUSTOM` (or your framework)
Description	`Quickstart test agent`

Connect

Click Connect Agent. The agent starts in ACTIVE status.

Via API: If you create agents through the API, active agents must include an owner. First fetch one stable membership id for your org:

curl https://conto.finance/api/organizations/me/members \
  -H "Authorization: Bearer $CONTO_ORG_API_KEY"

Pick members[].id for the org member or service account that should own the agent, then create the agent:

curl -X POST https://conto.finance/api/agents \
  -H "Authorization: Bearer $CONTO_ORG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Test Payment Agent",
    "agentType": "CUSTOM",
    "description": "Quickstart test agent",
    "ownerMembershipId": "mem_abc123..."
  }'

Valid agentType values: OPENAI_ASSISTANT, ANTHROPIC_CLAUDE, LANGCHAIN, AUTOGPT, CUSTOM. Agent statuses: ACTIVE, PAUSED, SUSPENDED, REVOKED.

Step 4. Link the wallet to the agent

Assign the wallet

Open the agent detail page. In the Wallets section, click Assign Wallet and pick the Tempo Testnet wallet.

Set spending limits

Recommended for the quickstart:

Setting	Value
Per Transaction	`50`
Daily Limit	`500`
Weekly Limit	`2000`
Monthly Limit	`5000`

Don’t set Per Transaction to 0. That blocks every payment at the wallet level before any policy runs. Use null (unlimited) or a positive value.

Default limits, time windows, and other agent-wallet link defaults are listed on the Defaults page.

Step 5. Generate an SDK key

Open SDK Integration

On the agent detail page, click the SDK Integration tab.

Generate the key

Click Generate New Key. Name it (e.g. Testnet Key). Keep the default expiresInDays. Choose an Admin SDK key if you want to complete the execution steps in this guide, because Step 8 calls POST /api/sdk/payments/{requestId}/execute. The default Standard SDK key preset is enough for request-only policy evaluation, but it does not include payments:execute.

Store the key immediately

The full key is shown once. Save it to your environment:

export CONTO_API_KEY="conto_agent_your_key_here"

For scopes and key types (standard vs admin), see Authentication. Verify the setup:

curl https://conto.finance/api/sdk/setup \
  -H "Authorization: Bearer $CONTO_API_KEY"

You should see:

agent.status is "ACTIVE"
wallets contains your Tempo Testnet wallet with a balance
scopes includes payments:request
if you chose an execute-capable key for this guide, scopes also includes payments:execute

Step 6. Create two test policies

These two policies together produce three different payment outcomes:

Policy A: spend limit

Create the policy

Sidebar > Policies > New Policy.

Field	Value
Name	`Test Spend Limit`
Policy Type	`SPEND_LIMIT`
Description	Deny transactions over $15

Add the rule

Field	Value
Rule Type	`MAX_AMOUNT`
Operator	`LTE`
Value	`15`
Action	`ALLOW`

Policy B: approval threshold

Create the policy

Field	Value
Name	`Test Approval Threshold`
Policy Type	`APPROVAL_THRESHOLD`
Description	Require approval for transactions over $10

Add the rule

Field	Value
Rule Type	`REQUIRE_APPROVAL_ABOVE`
Operator	`GREATER_THAN`
Value	`10`
Action	`REQUIRE_APPROVAL`

Assign both to the agent

Open the agent detail page > Permissions tab > assign Test Spend Limit and Test Approval Threshold. Policies combine with AND logic. The most restrictive outcome wins. Higher priority numbers evaluate first (default priority is 50).

Step 7. Run three test transactions

With both policies active you should see three different outcomes:

Amount	Expected outcome	Why
`5`	`APPROVED`	Under both thresholds
`12`	`REQUIRES_APPROVAL`	Over the $10 approval threshold, under the$ 15 spend limit
`20`	`DENIED`	Over the $15 spend limit

Test 1. `$5` should be APPROVED

curl -X POST https://conto.finance/api/sdk/payments/request \
  -H "Authorization: Bearer $CONTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 5,
    "recipientAddress": "0x1234567890abcdef1234567890abcdef12345678",
    "purpose": "Test - under all limits",
    "category": "TESTING"
  }'

Response: "status": "APPROVED", "currency": "pathUSD".

Test 2. `$12` should REQUIRE_APPROVAL

curl -X POST https://conto.finance/api/sdk/payments/request \
  -H "Authorization: Bearer $CONTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 12,
    "recipientAddress": "0x1234567890abcdef1234567890abcdef12345678",
    "purpose": "Test - over approval threshold"
  }'

Response: "status": "REQUIRES_APPROVAL" with a violation referencing the approval threshold.

Test 3. `$20` should be DENIED

curl -X POST https://conto.finance/api/sdk/payments/request \
  -H "Authorization: Bearer $CONTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 20,
    "recipientAddress": "0x1234567890abcdef1234567890abcdef12345678",
    "purpose": "Test - over max amount"
  }'

Response: "status": "DENIED" with a violation referencing the spend limit.

Step 8. Execute the approved payment

Replace REQUEST_ID with the requestId from Test 1: This step requires a key with the payments:execute scope.

curl -X POST https://conto.finance/api/sdk/payments/REQUEST_ID/execute \
  -H "Authorization: Bearer $CONTO_API_KEY"

The response includes:

txHash. Onchain transaction hash on Tempo Testnet.
explorerUrl. Link to view on explore.moderato.tempo.xyz.

Step 9. Same flow via the SDK

import { Conto } from '@conto/sdk';

const conto = new Conto({ apiKey: process.env.CONTO_API_KEY });

// Test 1
const test1 = await conto.payments.request({
  amount: 5,
  recipientAddress: '0x1234567890abcdef1234567890abcdef12345678',
  purpose: 'Test - under all limits',
});
console.log('Test 1:', test1.status); // APPROVED

if (test1.status === 'APPROVED') {
  const result = await conto.payments.execute(test1.requestId);
  console.log('TX hash:', result.txHash);
  console.log('Explorer:', result.explorerUrl);
}

// Test 2
const test2 = await conto.payments.request({
  amount: 12,
  recipientAddress: '0x1234567890abcdef1234567890abcdef12345678',
  purpose: 'Test - over approval threshold',
});
console.log('Test 2:', test2.status); // REQUIRES_APPROVAL

// Test 3
const test3 = await conto.payments.request({
  amount: 20,
  recipientAddress: '0x1234567890abcdef1234567890abcdef12345678',
  purpose: 'Test - over max amount',
});
console.log('Test 3:', test3.status); // DENIED

For one-call request + execute, set autoExecute: true on the request and ensure your key includes payments:execute.

Verify in the dashboard

After Step 8:

Dashboard > Transactions. The transaction shows Confirmed with the Tempo Testnet chain.
Click the explorer link to verify onchain.
Dashboard > Audit Logs. See the full policy evaluation trail.

You’ve verified policy enforcement and made a real onchain payment on Tempo Testnet.

Troubleshooting

All payments denied with 'per-transaction limit of $0'

The wallet-level per-transaction limit is 0. Edit the wallet limits on the agent detail page and set it to a positive value.

Payment denied but expected REQUIRES_APPROVAL

Policies combine with AND logic. If one policy denies while another requires approval, the denial wins. Check the Permissions tab for every assigned policy.

INSUFFICIENT_BALANCE

The testnet wallet needs funding. Use the Faucet button on the wallet detail page.

AUTH_FAILED

Invalid or expired SDK key. Generate a new one from the agent detail page.

Moving to production

Once the testnet flow works:

Create a production wallet on Tempo Mainnet (USDC.e), Base (USDC), or Solana (USDC).
Fund it with real stablecoins.
Link the production wallet to your agent with production-sized limits.
Update or create production policies. The test policies can remain for reference.

Your SDK integration code does not change. Only the wallet and chain change.

Next steps

Connect your framework

OpenAI, Claude, LangChain, Python integration snippets

SDK payments reference

Full method signatures, options, error model

Policy overview

All 14 policy types and rule types

Defaults

Every default value in one place

Documentation Index

​Quickstart

​What you’ll build

​Why Tempo Testnet?

​Choose Your Key Up Front

​Step 1. Create your account

​Step 2. Create and fund a wallet

​Step 3. Connect an agent

​Step 4. Link the wallet to the agent

​Step 5. Generate an SDK key

​Step 6. Create two test policies

​Policy A: spend limit

​Policy B: approval threshold

​Assign both to the agent

​Step 7. Run three test transactions

​Test 1. $5 should be APPROVED

​Test 2. $12 should REQUIRE_APPROVAL

​Test 3. $20 should be DENIED

​Step 8. Execute the approved payment

​Step 9. Same flow via the SDK

​Verify in the dashboard

​Troubleshooting

​Moving to production

​Next steps

Connect your framework

SDK payments reference

Policy overview

Defaults

Quickstart

What you’ll build

Why Tempo Testnet?

Choose Your Key Up Front

Step 1. Create your account

Step 2. Create and fund a wallet

Step 3. Connect an agent

Step 4. Link the wallet to the agent

Step 5. Generate an SDK key

Step 6. Create two test policies

Policy A: spend limit

Policy B: approval threshold

Assign both to the agent

Step 7. Run three test transactions

Test 1. `$5` should be APPROVED

Test 2. `$12` should REQUIRE_APPROVAL

Test 3. `$20` should be DENIED

Step 8. Execute the approved payment

Step 9. Same flow via the SDK

Verify in the dashboard

Troubleshooting

Moving to production

Next steps