Quickstart Guide

Deploy your first AI agent with financial autonomy in under 5 minutes.

Prerequisites

• ClawBank account (sign up)

• Service key or agent key from dashboard

• Solana wallet with USDC (devnet or mainnet)

Step 1: Install SDK

# TypeScript/Node.js
npm install @clawbank/sdk

# Python
pip install clawbank

# Go
go get github.com/ClawBank-app/go-sdk

Step 2: Initialize Client

import { ClawBank } from '@clawbank/sdk';

const client = new ClawBank({
  apiKey: process.env.CLAWBANK_API_KEY,
  environment: 'production', // 'sandbox' for testnet
  network: 'solana-mainnet' // or 'solana-devnet'
});

from clawbank import ClawBank

client = ClawBank(
    api_key=os.environ.get('CLAWBANK_API_KEY'),
    environment='production',
    network='solana-mainnet'
)

import "github.com/ClawBank-app/go-sdk"

client := clawbank.NewClient(&clawbank.Config{
    APIKey:      os.Getenv("CLAWBANK_API_KEY"),
    Environment: "production",
    Network:     "solana-mainnet",
})

Step 3: Create Treasury Vault

Treasury vaults are on-chain smart contracts that hold assets with programmable authorization.

const vault = await client.vaults.create({
  name: 'AI Agent Treasury',
  currency: 'USDC',
  network: 'solana',
  initialDeposit: 10000.00
});

console.log(`Vault address: ${vault.depositAddress}`);
console.log(`Smart contract: ${vault.programId}`);

Step 4: Configure Authorization Policy

Define programmable spending rules enforced at the smart contract layer.

await client.vaults.setAuthorizationPolicy(vault.id, {
  type: 'whitelist_only',
  dailyLimit: 5000,
  currency: 'USDC',
  merchants: ['aws.amazon.com', 'vercel.com', 'openai.com'],
  requiresApproval: {
    above: 1000,
    approvers: ['[email protected]'],
    threshold: 1
  },
  zkProofRequired: true
});

Step 5: Deploy MCP Server for AI Agents

Configure autonomous AI agent access via Model Context Protocol.

Option A: Claude Desktop Integration

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "clawbank": {
      "command": "npx",
      "args": ["-y", "@clawbank/mcp-server"],
      "env": {
        "CLAWBANK_AGENT_KEY": "ak_live_your_agent_key",
        "CLAWBANK_VAULT_ID": "vault_123"
      }
    }
  }
}

Option B: Programmatic MCP Client

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';

const transport = new StdioClientTransport({
  command: 'npx',
  args: ['-y', '@clawbank/mcp-server'],
  env: {
    CLAWBANK_AGENT_KEY: process.env.CLAWBANK_AGENT_KEY,
    CLAWBANK_VAULT_ID: vaultId
  }
});

const mcpClient = new Client({
  name: 'treasury-agent',
  version: '1.0.0'
}, {
  capabilities: {}
});

await mcpClient.connect(transport);

// Agent can now execute financial operations via natural language

Step 6: Execute First Transaction

// Via SDK (programmatic)
const transaction = await client.transactions.create({
  vaultId: vault.id,
  amount: 99.00,
  currency: 'USDC',
  recipient: 'merchant_wallet_address',
  memo: 'Infrastructure payment'
});

console.log(`Transaction hash: ${transaction.signatur}`);
console.log(`Explorer: https://solscan.io/tx/${transaction.signature}`);

Complete Example: AI Agent Treasury

import { ClawBank } from '@clawbank/sdk';

async function deployAgentTreasury() {
  const client = new ClawBank({
    apiKey: process.env.CLAWBANK_API_KEY,
    environment: 'production',
    network: 'solana-mainnet'
  });

  // Create treasury vault
  const vault = await client.vaults.create({
    name: 'AI Operations Treasury',
    currency: 'USDC',
    network: 'solana',
    initialDeposit: 50000.00,
    metadata: {
      agent: 'operations-ai',
      purpose: 'autonomous_payments'
    }
  });

  // Configure programmable authorization
  await client.vaults.setAuthorizationPolicy(vault.id, {
    type: 'whitelist_only',
    dailyLimit: 2000,
    merchants: [
      'aws.amazon.com',
      'openai.com',
      'anthropic.com'
    ],
    requiresApproval: {
      above: 500,
      approvers: ['[email protected]'],
      threshold: 1,
      timeoutMinutes: 30
    },
    velocityControl: {
      maxTransactionsPerHour: 10,
      maxAmountPerHour: 5000
    },
    zkProofRequired: true
  });

  // Deploy agent authorization key
  const agentKey = await client.agents.keys.create({
    vaultId: vault.id,
    name: 'Operations AI Agent',
    permissions: [
      'transactions:create',
      'balance:read',
      'transactions:read'
    ],
    limits: {
      maxTransactionAmount: 500,
      dailyLimit: 2000
    }
  });

  console.log('Agent treasury deployed');
  console.log(`Vault address: ${vault.depositAddress}`);
  console.log(`Agent key: ${agentKey.key}`);
  console.log(`Smart contract: ${vault.programId}`);

  return { vault, agentKey };
}

deployAgentTreasury().catch(console.error);

Devnet Testing

Test with Solana devnet before mainnet deployment:

const client = new ClawBank({
  apiKey: process.env.CLAWBANK_DEVNET_KEY,
  environment: 'sandbox',
  network: 'solana-devnet'
});

// All operations identical to mainnet
// Devnet USDC is test currency with no real value

Get devnet USDC: spl-token-faucet.com

Next Steps

• Agent Authentication - Configure AI agent access

• Authorization Engine - Programmable spending policies

• Treasury Vaults - On-chain smart contract operations

• MCP Integration - AI agent protocol implementation

• API Reference - Complete endpoint documentation

Support

• Technical Issues: [email protected]

• Smart Contract Questions: [email protected]

• Documentation: docs.useclawbank.com

• Discord: discord.gg/clawbank