Crypto Wallet API Quickstart: Generate Wallets and Broadcast Transactions in 10 Minutes

May 29, 2026

Academy

shareToTwitter shareToLinkedin shareToTelegram shareToCopy

Key Takeaways

A crypto wallet API enables programmatic wallet creation, address generation, and transaction management without building blockchain infrastructure
Cobo's WaaS 2.0 API supports 80+ blockchains with unified endpoints for all wallet types
This tutorial covers the complete flow: SDK installation, authentication, wallet creation, and sending your first transaction
Both Python and JavaScript SDKs are available with identical functionality
The development environment lets you test everything without real funds before going to production

Building crypto wallet functionality from scratch requires months of development and deep blockchain expertise. A crypto wallet API eliminates that complexity by providing ready-to-use endpoints for wallet operations.

This quickstart guide walks you through integrating a crypto wallet API in under 10 minutes. By the end, you'll have working code that creates wallets, generates deposit addresses, checks balances, and broadcasts transactions.

What is a Crypto Wallet API?

A crypto wallet API is a programmatic interface that handles blockchain wallet operations on your behalf. Instead of running nodes, managing private keys, and implementing transaction signing yourself, you make simple API calls.

Core capabilities include:

Wallet Management: Create and organize wallets programmatically
Address Generation: Generate deposit addresses for any supported blockchain
Balance Queries: Check token balances across chains in real-time
Transaction Submission: Sign and broadcast transactions to the blockchain
Webhook Notifications: Receive real-time updates on deposits and confirmations

Cobo's Wallet as a Service (WaaS) 2.0 API provides all of these capabilities with support for 80+ blockchains and 3,000+ tokens through a unified interface.

Prerequisites

Before starting, you'll need:

Cobo Account: Sign up for a free account and create an organization
API Credentials: Generate an API key and API secret from Cobo Portal
Development Environment: Python 3.7+ or Node.js 14+

Tip: Use the development environment (api.dev.cobo.com) for testing. It provides test funds and doesn't affect real assets.

Step 1: Install the SDK

Choose your preferred language and install the SDK:

Python

# Install the latest version (check GitHub for current version number)
pip install cobo-waas2

Note: For production, specify a version: pip install cobo-waas2==1.2.0. Check the GitHub repository for the latest version.

JavaScript

npm install @cobo/cobo-waas2 --save

For complete SDK documentation, visit the Cobo Developer Hub.

Step 2: Configure Authentication

Initialize the API client with your credentials. The SDK handles request signing automatically.

Python

import cobo_waas2

# Configure API client
configuration = cobo_waas2.Configuration(
    # Replace with your API secret
    api_private_key="<YOUR_API_SECRET>",
    # Use api.dev.cobo.com for development, api.cobo.com for production
    host="https://api.dev.cobo.com/v2"
)

JavaScript

const CoboWaas2 = require('@cobo/cobo-waas2');

// Initialize the API client
const apiClient = CoboWaas2.ApiClient.instance;

// Set your API secret (in hex format)
apiClient.setPrivateKey("<YOUR_API_SECRET_IN_HEX>");

// Set environment: DEV for development, PROD for production
apiClient.setEnv(CoboWaas2.Env.DEV);

Security Note: Never hardcode API secrets in your code. Use environment variables or a secrets manager in production.

Step 3: Create a Wallet

Create your first custodial wallet. This wallet will hold assets and generate addresses for deposits. For enterprise use cases requiring distributed key management, consider MPC wallets instead.

Python

import cobo_waas2
from cobo_waas2 import CreateCustodialWalletParams, WalletType, WalletSubtype

configuration = cobo_waas2.Configuration(
    api_private_key="<YOUR_API_SECRET>",
    host="https://api.dev.cobo.com/v2"
)

# Use context manager for proper resource handling
with cobo_waas2.ApiClient(configuration) as api_client:
    # Create an instance of the Wallets API
    api_instance = cobo_waas2.WalletsApi(api_client)
    
    # Define wallet parameters
    create_wallet_params = cobo_waas2.CreateWalletParams(
        actual_instance=CreateCustodialWalletParams(
            name="My First Wallet",
            wallet_type=WalletType.CUSTODIAL,
            wallet_subtype=WalletSubtype.ASSET,
        ),
    )
    
    try:
        # Create the wallet
        api_response = api_instance.create_wallet(
            create_wallet_params=create_wallet_params
        )
        print("Wallet created successfully!")
        print(f"Wallet ID: {api_response.wallet_id}")
        print(f"Wallet Name: {api_response.name}")
    except Exception as e:
        print(f"Error creating wallet: {e}")

JavaScript

const CoboWaas2 = require('@cobo/cobo-waas2');

// Initialize the API client
const apiClient = CoboWaas2.ApiClient.instance;
apiClient.setEnv(CoboWaas2.Env.DEV);
apiClient.setPrivateKey("<YOUR_API_SECRET_IN_HEX>");

// Create a WalletsApi instance
const apiInstance = new CoboWaas2.WalletsApi();

// Define wallet parameters
const opts = {
    CreateWalletParams: CoboWaas2.CreateWalletParams.constructFromObject({
        name: "My First Wallet",
        wallet_type: "Custodial",
        wallet_subtype: "Asset"
    })
};

// Create the wallet
apiInstance.createWallet(opts).then(
    (data) => {
        console.log("Wallet created successfully!");
        console.log("Wallet ID:", data.wallet_id);
        console.log("Wallet Name:", data.name);
    },
    (error) => {
        console.error("Error creating wallet:", error);
    }
);

Expected Response:

{
    "wallet_id": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "wallet_type": "Custodial",
    "wallet_subtype": "Asset",
    "name": "My First Wallet",
    "org_id": "your-org-id"
}

Step 4: Generate a Deposit Address

Generate an address to receive crypto deposits. Each address is unique and linked to your wallet.

Python

import cobo_waas2

configuration = cobo_waas2.Configuration(
    api_private_key="<YOUR_API_SECRET>",
    host="https://api.dev.cobo.com/v2"
)

with cobo_waas2.ApiClient(configuration) as api_client:
    api_instance = cobo_waas2.WalletsApi(api_client)
    
    wallet_id = "<YOUR_WALLET_ID>"
    chain_id = "ETH"  # Ethereum mainnet
    
    try:
        api_response = api_instance.create_address(
            wallet_id=wallet_id,
            chain_id=chain_id
        )
        print("Address generated successfully!")
        print(f"Address: {api_response.address}")
        print(f"Chain: {api_response.chain_id}")
    except Exception as e:
        print(f"Error generating address: {e}")

JavaScript

const CoboWaas2 = require('@cobo/cobo-waas2');

const apiClient = CoboWaas2.ApiClient.instance;
apiClient.setEnv(CoboWaas2.Env.DEV);
apiClient.setPrivateKey("<YOUR_API_SECRET_IN_HEX>");

const apiInstance = new CoboWaas2.WalletsApi();

const walletId = "<YOUR_WALLET_ID>";
const opts = {
    chain_id: "ETH"  // Ethereum mainnet
};

apiInstance.createAddress(walletId, opts).then(
    (data) => {
        console.log("Address generated successfully!");
        console.log("Address:", data.address);
        console.log("Chain:", data.chain_id);
    },
    (error) => {
        console.error("Error generating address:", error);
    }
);

Expected Response:

{
    "address": "0x742d35Cc6634C0532925a3b844Bc9e7595f...",
    "chain_id": "ETH",
    "wallet_id": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "encoding": "EVM_ADDRESS"
}

Step 5: Check Wallet Balance

Query the balance of your wallet across all tokens or for a specific asset.

Python

import cobo_waas2

configuration = cobo_waas2.Configuration(
    api_private_key="<YOUR_API_SECRET>",
    host="https://api.dev.cobo.com/v2"
)

with cobo_waas2.ApiClient(configuration) as api_client:
    api_instance = cobo_waas2.WalletsApi(api_client)
    
    wallet_id = "<YOUR_WALLET_ID>"
    
    try:
        api_response = api_instance.list_token_balances_for_wallet(
            wallet_id=wallet_id
        )
        print("Wallet Balances:")
        for balance in api_response.data:
            print(f"  {balance.token_id}: {balance.balance.total}")
    except Exception as e:
        print(f"Error fetching balances: {e}")

JavaScript

const CoboWaas2 = require('@cobo/cobo-waas2');

const apiClient = CoboWaas2.ApiClient.instance;
apiClient.setEnv(CoboWaas2.Env.DEV);
apiClient.setPrivateKey("<YOUR_API_SECRET_IN_HEX>");

const apiInstance = new CoboWaas2.WalletsApi();
const walletId = "<YOUR_WALLET_ID>";

apiInstance.listTokenBalancesForWallet(walletId).then(
    (data) => {
        console.log("Wallet Balances:");
        data.data.forEach(balance => {
            console.log(`  ${balance.token_id}: ${balance.balance.total}`);
        });
    },
    (error) => {
        console.error("Error fetching balances:", error);
    }
);

Expected Response:

{
    "data": [
        {
            "token_id": "ETH",
            "balance": {
                "total": "1.5",
                "available": "1.5",
                "pending": "0"
            }
        },
        {
            "token_id": "USDT_ETH",
            "balance": {
                "total": "1000.00",
                "available": "1000.00",
                "pending": "0"
            }
        }
    ]
}

Step 6: Send a Transaction

Broadcast a transaction to transfer tokens. The API handles signing and blockchain submission.

Python

import cobo_waas2

configuration = cobo_waas2.Configuration(
    api_private_key="<YOUR_API_SECRET>",
    host="https://api.dev.cobo.com/v2"
)

with cobo_waas2.ApiClient(configuration) as api_client:
    api_instance = cobo_waas2.TransactionsApi(api_client)
    
    wallet_id = "<YOUR_WALLET_ID>"
    
    # Create transfer parameters
    transfer_params = cobo_waas2.TransferParams(
        request_id="unique-request-id-123",  # Your unique ID for idempotency
        source={
            "source_type": "Asset",
            "wallet_id": wallet_id
        },
        token_id="ETH",
        destination={
            "destination_type": "Address",
            "account_output": {
                "address": "0xRecipientAddress...",
                "amount": "0.1"
            }
        }
    )
    
    try:
        api_response = api_instance.create_transfer_transaction(
            transfer_params=transfer_params
        )
        print("Transaction submitted!")
        print(f"Transaction ID: {api_response.transaction_id}")
        print(f"Status: {api_response.status}")
    except Exception as e:
        print(f"Error sending transaction: {e}")

JavaScript

const CoboWaas2 = require('@cobo/cobo-waas2');

const apiClient = CoboWaas2.ApiClient.instance;
apiClient.setEnv(CoboWaas2.Env.DEV);
apiClient.setPrivateKey("<YOUR_API_SECRET_IN_HEX>");

const apiInstance = new CoboWaas2.TransactionsApi();
const walletId = "<YOUR_WALLET_ID>";

const opts = {
    TransferParams: CoboWaas2.TransferParams.constructFromObject({
        request_id: "unique-request-id-123",
        source: {
            source_type: "Asset",
            wallet_id: walletId
        },
        token_id: "ETH",
        destination: {
            destination_type: "Address",
            account_output: {
                address: "0xRecipientAddress...",
                amount: "0.1"
            }
        }
    })
};

apiInstance.createTransferTransaction(opts).then(
    (data) => {
        console.log("Transaction submitted!");
        console.log("Transaction ID:", data.transaction_id);
        console.log("Status:", data.status);
    },
    (error) => {
        console.error("Error sending transaction:", error);
    }
);

Expected Response:

{
    "transaction_id": "tx_abc123def456",
    "request_id": "unique-request-id-123",
    "status": "Submitted",
    "created_timestamp": 1699900000000
}

Step 7: Monitor with Webhooks

Set up webhooks to receive real-time notifications when transactions are confirmed or deposits arrive.

Configure your webhook endpoint in the Cobo Portal Developer Console. The API will send POST requests to your endpoint for events like:

transaction.created - New transaction initiated
transaction.success - Transaction confirmed on-chain
transaction.failed - Transaction failed
deposit.confirmed - Incoming deposit confirmed

Example Webhook Payload:

{
    "event_type": "transaction.success",
    "timestamp": 1699900000000,
    "data": {
        "transaction_id": "tx_abc123def456",
        "status": "Completed",
        "tx_hash": "0x123abc...",
        "confirmations": 12
    }
}

Common Errors and Troubleshooting

Error	Cause	Solution
`401 Unauthorized`	Invalid API credentials	Check API key and secret; ensure they're registered in Cobo Portal
`403 Forbidden`	Insufficient permissions	Verify your API key has the required scopes for the operation
`400 Bad Request`	Invalid parameters	Check required fields and parameter formats in the API documentation
`429 Too Many Requests`	Rate limit exceeded	Implement exponential backoff; contact support for higher limits
`Insufficient Balance`	Not enough funds	Deposit funds to your wallet before attempting transfers

Next Steps

You've successfully integrated a crypto wallet API. Here's what to explore next:

Full API Reference: Explore all available endpoints and parameters
MPC Wallets: Set up institutional-grade wallets with distributed key management
Smart Contract Wallets: Integrate programmable wallets with advanced access controls
Transaction Policies: Configure approval workflows and spending limits
WaaS for Fintech: Learn how fintech platforms leverage wallet APIs

Ready to build? Start your 14-day free trial with full API access and dedicated support.

FAQ

How many blockchains does the crypto wallet API support?

Cobo's WaaS 2.0 API supports 80+ blockchains including Bitcoin, Ethereum, Polygon, Arbitrum, Solana, Tron, and many more. New chains are added regularly. The unified API means you use the same code patterns regardless of which blockchain you're working with.

What's the difference between development and production environments?

The development environment (api.dev.cobo.com) provides test funds and isolated wallets for safe experimentation. No real assets are at risk. The production environment (api.cobo.com) connects to live blockchains with real assets. Always test thoroughly in development before deploying to production.

How do I secure my API credentials?

Never commit API secrets to version control. Use environment variables or a secrets manager like AWS Secrets Manager or HashiCorp Vault. Rotate API keys periodically and use the minimum required permissions for each key. Enable IP allowlisting in Cobo Portal for additional security.

Can I use MPC wallets instead of custodial wallets?

Yes. Cobo supports four wallet types: Custodial, MPC (Organization-Controlled and User-Controlled), Smart Contract, and Exchange Wallets. MPC wallets provide enhanced security by distributing key shares across multiple parties. The API patterns are similar, just use the MPC-specific endpoints and parameters.

View more

Cold Wallet vs Hot Wallet: What Crypto Exchanges and Users Need to Know in 2025

June 17, 2025

Stablecoin Payments 101 for PSPs: How to Integrate Digital Dollars Without Rebuilding Your Stack

December 11, 2025

Cobo vs. Fireblocks: Choosing the Right Digital Asset Custody Provider for Your Business

June 17, 2025