Quickstart Guide

Deploy your first AI agent treasury account in minutes.

Prerequisites

• Node.js 18+ or Python 3.9+

• Clawallex API credentials (sign up at clawallex.app)

Installation

TypeScript/Node.js

npm install @clawallex/sdk

Python

pip install clawallex

Go

go get github.com/clawallex/clawallex-go

Your First Treasury Account

TypeScript

import { Clawallex } from '@clawallex/sdk';

const clawallex = new Clawallex({
  apiKey: process.env.CLAWALLEX_API_KEY
});

// Create treasury account
const account = await clawallex.accounts.create({
  name: 'AI Agent Operating Account',
  currency: 'USD',
  metadata: {
    agent_id: 'agent_001',
    purpose: 'operational_expenses'
  }
});

console.log('Account created:', account.id);
console.log('Current balance:', account.balance);

Python

import clawallex
import os

client = clawallex.Client(
    api_key=os.environ.get('CLAWALLEX_API_KEY')
)

# Create treasury account
account = client.accounts.create(
    name='AI Agent Operating Account',
    currency='USD',
    metadata={
        'agent_id': 'agent_001',
        'purpose': 'operational_expenses'
    }
)

print(f'Account created: {account.id}')
print(f'Current balance: {account.balance}')

Go

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/clawallex/clawallex-go"
)

func main() {
    client := clawallex.New(os.Getenv("CLAWALLEX_API_KEY"))

    // Create treasury account
    account, err := client.Accounts.Create(context.Background(), &clawallex.AccountCreateParams{
        Name:     "AI Agent Operating Account",
        Currency: "USD",
        Metadata: map[string]string{
            "agent_id": "agent_001",
            "purpose":  "operational_expenses",
        },
    })

    if err != nil {
        panic(err)
    }

    fmt.Printf("Account created: %s\n", account.ID)
    fmt.Printf("Current balance: %.2f\n", account.Balance)
}

Configure Spending Policy

// Set programmable authorization rules
await clawallex.policies.create(account.id, {
  limits: {
    daily: 5000,
    monthly: 100000,
    perTransaction: 10000
  },
  merchants: {
    whitelist: [
      'aws.amazon.com',
      'openai.com',
      'vercel.com',
      'stripe.com'
    ]
  },
  approvals: {
    threshold: 10000,
    approvers: ['[email protected]'],
    minApprovers: 1,
    timeoutMinutes: 60
  }
});

console.log('Spending policy configured');

Issue Virtual Card

// Create card linked to treasury account
const card = await clawallex.cards.create({
  accountId: account.id,
  type: 'virtual',
  cardholderName: 'AI Agent 001',
  limits: {
    perTransaction: 1000,
    daily: 5000,
    monthly: 50000
  },
  allowedCategories: [
    'cloud_services',
    'software',
    'advertising'
  ]
});

console.log('Card number:', card.maskedNumber);
console.log('CVV:', card.cvv);
console.log('Expires:', `${card.expiryMonth}/${card.expiryYear}`);

Execute Transfer

// Create internal transfer
const transfer = await clawallex.transfers.create({
  sourceAccountId: account.id,
  destinationAccountId: 'acc_vendor_123',
  amount: 500,
  currency: 'USD',
  memo: 'Invoice #1234 payment'
});

console.log('Transfer ID:', transfer.id);
console.log('Status:', transfer.status); // 'completed' (instant)
console.log('Settlement time:', transfer.settledAt);

Query Balance

// Real-time balance query
const balance = await clawallex.accounts.getBalance(account.id);

console.log('Available:', balance.available);
console.log('Pending:', balance.pending);
console.log('Total:', balance.total);

List Transactions

// Query transaction history
const transactions = await clawallex.transactions.list({
  accountId: account.id,
  limit: 10,
  status: 'completed'
});

transactions.data.forEach(txn => {
  console.log(`${txn.createdAt}: $${txn.amount} - ${txn.description}`);
});

Enable MCP Integration

For AI agents using Model Context Protocol:

import { MCPClient } from '@modelcontextprotocol/sdk';

// Connect to Clawallex MCP server
const mcp = new MCPClient({
  serverUrl: 'https://mcp.clawallex.app',
  apiKey: process.env.CLAWALLEX_API_KEY
});

// Agent can now use natural language commands
// "Send $500 to AWS for compute"
// "What did we spend on software last month?"
// "Create a new card with $1000 daily limit"

See MCP Protocol documentation for complete integration guide.

Setup Webhooks

Receive real-time notifications for all account events:

// Create webhook endpoint
const webhook = await clawallex.webhooks.create({
  url: 'https://api.yourcompany.com/webhooks/clawallex',
  events: [
    'transaction.created',
    'transaction.completed',
    'authorization.required',
    'card.declined',
    'balance.low'
  ],
  secret: 'whsec_your_secret_key'
});

console.log('Webhook created:', webhook.id);

Complete Example: Agent Treasury Setup

import { Clawallex } from '@clawallex/sdk';

async function setupAgentTreasury() {
  const clawallex = new Clawallex({
    apiKey: process.env.CLAWALLEX_API_KEY
  });

  // 1. Create treasury account
  const account = await clawallex.accounts.create({
    name: 'OpenClaw Agent - Infrastructure',
    currency: 'USD',
    metadata: {
      agent_id: 'openclaw_infra_001',
      department: 'Engineering',
      environment: 'production'
    }
  });

  // 2. Configure spending policy
  await clawallex.policies.create(account.id, {
    limits: {
      daily: 10000,
      monthly: 200000
    },
    merchants: {
      whitelist: [
        'aws.amazon.com',
        'gcp.google.com',
        'vercel.com',
        'openai.com',
        'anthropic.com'
      ]
    },
    approvals: {
      threshold: 5000,
      approvers: ['[email protected]', '[email protected]'],
      minApprovers: 1,
      timeoutMinutes: 120
    },
    schedule: {
      allowedDays: [1, 2, 3, 4, 5], // Monday-Friday
      allowedHours: [9, 17], // 9 AM - 5 PM
      timezone: 'America/New_York'
    }
  });

  // 3. Issue virtual cards
  const cards = await Promise.all([
    // Cloud infrastructure card
    clawallex.cards.create({
      accountId: account.id,
      type: 'virtual',
      cardholderName: 'Agent - Cloud Services',
      limits: { daily: 5000 },
      allowedMerchants: ['aws.amazon.com', 'gcp.google.com']
    }),

    // AI services card
    clawallex.cards.create({
      accountId: account.id,
      type: 'virtual',
      cardholderName: 'Agent - AI Services',
      limits: { daily: 2000 },
      allowedMerchants: ['openai.com', 'anthropic.com']
    })
  ]);

  // 4. Setup webhooks
  await clawallex.webhooks.create({
    url: 'https://api.company.com/webhooks/clawallex',
    events: [
      'transaction.*',
      'authorization.required',
      'balance.low',
      'card.declined'
    ]
  });

  // 5. Fund account
  console.log('Fund your account by transferring to:');
  console.log('Account ID:', account.id);
  console.log('Routing details:', account.routingDetails);

  return {
    account,
    cards,
    message: 'Agent treasury configured successfully'
  };
}

setupAgentTreasury()
  .then(result => console.log(result))
  .catch(error => console.error('Setup failed:', error));

Sandbox Mode

Test all operations without real money:

const clawallex = new Clawallex({
  apiKey: process.env.CLAWALLEX_SANDBOX_KEY,
  environment: 'sandbox'
});

// All operations work identically
// Transactions are simulated
// No real money moves

Sandbox API key available at: clawallex.app/settings/api-keys

Next Steps

• Authentication Guide - Secure API key management and rotation

• Treasury Accounts - Advanced account operations

• Card Issuing - Virtual and physical card management

• MCP Protocol - AI agent integration patterns

• Authorization Engine - Policy configuration

• Webhooks - Real-time event handling

API Reference

Complete endpoint documentation: reference/api.md

Support

• Documentation: docs.clawallex.app

• API Status: status.clawallex.app

• Discord: discord.gg/clawallex

• Email: [email protected]