This guide covers how to test your Dakota Platform API integration using our sandbox environment.

Sandbox Environment

Note: The sandbox environment (api.platform.sandbox.dakota.xyz) is not currently available but will be released shortly. For testing during development, please use the production environment with caution.

The Dakota Platform sandbox provides a safe testing environment that mirrors production:

Base URL: https://api.platform.sandbox.dakota.xyz
Dashboard: https://platform.sandbox.dakota.xyz
API Keys: Base64-encoded strings (e.g., AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=)

Getting Started

1. Create Sandbox Account

Ask Dakota Support for a Sandbox account login
Go to the Dashboard: https://platform.sandbox.dakota.xyz
Generate test API keys
Note the different behavior of sandbox vs production

2. Sandbox Limitations

No real money or crypto involved
Simulated payment processing
Limited external provider integrations
Faster processing times for testing

Testing KYB Onboarding

Sandbox KYB Behavior

In sandbox, KYB verification is simulated:

// Create test customer
const customer = await dakota.customers.create({
  customer_type: "business",
  name: "Test Business",
  email: "test@business.com"
});

// Initiate KYB - will return test onboarding URL
const kyb = await dakota.customers.kyb.create(customer.id, {
  provider: "persona"
});

// Simulate completion - status changes automatically in sandbox

KYB Test Scenarios

Control KYB outcomes using specific email patterns:

Email Pattern	KYB Result
`approved@test.com`	Auto-approved
`rejected@test.com`	Auto-rejected
`pending@test.com`	Stays pending
`review@test.com`	Requires manual review

Testing Transactions

Transaction Test Cases

Successful Onramp

cURL

# Successful onramp transaction
curl -X POST https://api.platform.sandbox.dakota.xyz/transactions/one-off \
  -H "X-API-Key: AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=" \
  -H "X-Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
    "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
    "source_asset": "USD",
    "source_network_id": "fiat",
    "destination_asset": "USDC",
    "destination_network_id": "ethereum-mainnet",
    "amount": {
      "value": "100.00",
      "asset": "USD"
    }
  }'

JavaScript

// Successful onramp transaction
const transaction = await fetch('https://api.platform.sandbox.dakota.xyz/transactions/one-off', {
  method: 'POST',
  headers: {
    'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
    'X-Idempotency-Key': crypto.randomUUID(),
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    customer_id: '31TgvwFzi3rstV0DEDzQtuBfwFR',
    destination_id: '31TgvySz1ARnqMZUdbuxykqqxGV',
    source_asset: 'USD',
    source_network_id: 'fiat',
    destination_asset: 'USDC',
    destination_network_id: 'ethereum-mainnet',
    amount: {
      value: '100.00',
      asset: 'USD'
    }
  })
});

Python

# Successful onramp transaction
transaction_response = requests.post(
    'https://api.platform.sandbox.dakota.xyz/transactions/one-off',
    headers={
        'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
        'X-Idempotency-Key': str(uuid.uuid4()),
        'Content-Type': 'application/json'
    },
    json={
        'customer_id': '31TgvwFzi3rstV0DEDzQtuBfwFR',
        'destination_id': '31TgvySz1ARnqMZUdbuxykqqxGV',
        'source_asset': 'USD',
        'source_network_id': 'fiat',
        'destination_asset': 'USDC',
        'destination_network_id': 'ethereum-mainnet',
        'amount': {
            'value': '100.00',
            'asset': 'USD'
        }
    }
)

Failed Transaction (Insufficient Funds)

cURL

# Transaction that will fail due to large amount
curl -X POST https://api.platform.sandbox.dakota.xyz/transactions/one-off \
  -H "X-API-Key: AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=" \
  -H "X-Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
    "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
    "source_asset": "USD",
    "source_network_id": "fiat",
    "destination_asset": "USDC",
    "destination_network_id": "ethereum-mainnet",
    "amount": {
      "value": "999999.00",
      "asset": "USD"
    }
  }'

JavaScript

// Transaction that will fail due to large amount
const transaction = await fetch('https://api.platform.sandbox.dakota.xyz/transactions/one-off', {
  method: 'POST',
  headers: {
    'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
    'X-Idempotency-Key': crypto.randomUUID(),
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    customer_id: '31TgvwFzi3rstV0DEDzQtuBfwFR',
    destination_id: '31TgvySz1ARnqMZUdbuxykqqxGV',
    source_asset: 'USD',
    source_network_id: 'fiat',
    destination_asset: 'USDC',
    destination_network_id: 'ethereum-mainnet',
    amount: {
      value: '999999.00', // Will fail
      asset: 'USD'
    }
  })
});

Python

# Transaction that will fail due to large amount
transaction_response = requests.post(
    'https://api.platform.sandbox.dakota.xyz/transactions/one-off',
    headers={
        'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
        'X-Idempotency-Key': str(uuid.uuid4()),
        'Content-Type': 'application/json'
    },
    json={
        'customer_id': '31TgvwFzi3rstV0DEDzQtuBfwFR',
        'destination_id': '31TgvySz1ARnqMZUdbuxykqqxGV',
        'source_asset': 'USD',
        'source_network_id': 'fiat',
        'destination_asset': 'USDC',
        'destination_network_id': 'ethereum-mainnet',
        'amount': {
            'value': '999999.00',  # Will fail
            'asset': 'USD'
        }
    }
)

package main

import (
    "bytes"
    "net/http"
    "github.com/google/uuid"
)

func main() {
    client := &http.Client{}
    body := bytes.NewBufferString(`{
        "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
        "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
        "source_asset": "USD",
        "source_network_id": "fiat",
        "destination_asset": "USDC",
        "destination_network_id": "ethereum-mainnet",
        "amount": {
            "value": "999999.00",
            "asset": "USD"
        }
    }`)
    
    req, _ := http.NewRequest("POST", "https://api.platform.sandbox.dakota.xyz/transactions/one-off", body)
    
    req.Header.Add("X-API-Key", "AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=")
    req.Header.Add("X-Idempotency-Key", uuid.New().String())
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

Rust

use reqwest::header::{HeaderMap, HeaderValue};
use uuid::Uuid;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    
    let mut headers = HeaderMap::new();
    headers.insert("X-API-Key", HeaderValue::from_static("AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc="));
    headers.insert("X-Idempotency-Key", HeaderValue::from_str(&Uuid::new_v4().to_string())?);
    headers.insert("Content-Type", HeaderValue::from_static("application/json"));
    
    let body = json!({
        "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
        "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
        "source_asset": "USD",
        "source_network_id": "fiat",
        "destination_asset": "USDC",
        "destination_network_id": "ethereum-mainnet",
        "amount": {
            "value": "999999.00",
            "asset": "USD"
        }
    });
    
    let response = client
        .post("https://api.platform.sandbox.dakota.xyz/transactions/one-off")
        .headers(headers)
        .json(&body)
        .send()
        .await?;
    
    Ok(())
}

Java

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.UUID;

public class DakotaFailedTransactionExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        String body = """
            {
              "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
              "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
              "source_asset": "USD",
              "source_network_id": "fiat",
              "destination_asset": "USDC",
              "destination_network_id": "ethereum-mainnet",
              "amount": {
                "value": "999999.00",
                "asset": "USD"
              }
            }
            """;
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.platform.sandbox.dakota.xyz/transactions/one-off"))
            .header("X-API-Key", "AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=")
            .header("X-Idempotency-Key", UUID.randomUUID().toString())
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
            
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
    }
}

Simulated Processing Times

In sandbox, transactions complete faster:

Onramp: 30 seconds to 2 minutes
Offramp: 1-3 minutes
Swap: 10-30 seconds
Failed: Immediate

Webhook Testing

Test Webhook Events

Trigger test webhooks manually:

POST /v1/test/webhooks/trigger

{
  "event": "transaction.status.updated",
  "webhook_target_id": "wh_test_123",
  "data": {
    "transaction_id": "31TgvtxUdXi95dUN4M8X1rhSCNS",
    "status": "completed"
  }
}

Webhook Testing Tools

ngrok for Local Development

# Expose local server
ngrok http 3000

# Use HTTPS URL for webhook registration  
curl -X POST https://api.platform.sandbox.dakota.xyz/webhooks/targets \
  -H "X-API-Key: your-api-key" \
  -H "X-Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://abc123.ngrok.io/webhooks", "active": true}'

Webhook.site for Quick Testing

Visit webhook.site
Copy the unique URL
Register it as your webhook endpoint
View real-time webhook deliveries

Integration Testing Checklist

Authentication

API keys work in sandbox
Error handling for invalid keys
Rate limiting behavior
Proper header format

Customer Management

Create customers successfully
Handle validation errors
KYB flow integration
Status polling/webhooks

Transaction Processing

Successful transaction creation
Transaction estimation accuracy
Error handling (insufficient funds, invalid addresses)
Status tracking and webhooks
Idempotency key usage

Webhook Handling

Error Simulation

Force Specific Errors

Use special values to trigger errors in sandbox:

Transaction Errors

// Force insufficient funds error
{ source_amount: { value: "999999.00", currency: "USD" }}

// Force invalid address error  
{ destination: { address: "invalid_address" }}

// Force rate limit error
// Make 150+ requests in 1 minute with same key

KYB Errors

// Force KYB rejection
{ email: "rejected@test.com" }

// Force timeout
{ email: "timeout@test.com" }

Load Testing

Rate Limit Testing

Test your rate limit handling:

cURL

# Simple rate limit test - run this script
for i in {1..150}; do
  curl -X GET https://api.platform.sandbox.dakota.xyz/customers \
    -H "X-API-Key: AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=" &
done
wait

JavaScript

async function testRateLimit() {
  const promises = [];
  
  // Make 150 concurrent requests
  for (let i = 0; i < 150; i++) {
    promises.push(
      fetch('https://api.platform.sandbox.dakota.xyz/customers', {
        headers: {
          'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc='
        }
      }).catch(err => err)
    );
  }
  
  const results = await Promise.all(promises);
  const rateLimited = results.filter(r => r.status === 429);
  
  console.log(`${rateLimited.length} requests were rate limited`);
}

Python

import asyncio
import aiohttp

async def test_rate_limit():
    async with aiohttp.ClientSession() as session:
        tasks = []
        
        # Make 150 concurrent requests
        for i in range(150):
            task = session.get(
                'https://api.platform.sandbox.dakota.xyz/customers',
                headers={'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc='}
            )
            tasks.append(task)
        
        responses = await asyncio.gather(*tasks, return_exceptions=True)
        rate_limited = [r for r in responses if hasattr(r, 'status') and r.status == 429]
        
        print(f'{len(rate_limited)} requests were rate limited')

# Run the test
asyncio.run(test_rate_limit())

Transaction Volume Testing

cURL

# Transaction volume test - run multiple transactions
for i in {1..10}; do
  curl -X POST https://api.platform.sandbox.dakota.xyz/transactions/one-off \
    -H "X-API-Key: AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=" \
    -H "X-Idempotency-Key: $(uuidgen)" \
    -H "Content-Type: application/json" \
    -d '{
      "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
      "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
      "source_asset": "USD",
      "source_network_id": "fiat",
      "destination_asset": "USDC",
      "destination_network_id": "ethereum-mainnet",
      "amount": {
        "value": "10.00",
        "asset": "USD"
      }
    }' &
done
wait

JavaScript

async function testTransactionVolume() {
  const transactions = [];
  
  for (let i = 0; i < 10; i++) {
    transactions.push(
      fetch('https://api.platform.sandbox.dakota.xyz/transactions/one-off', {
        method: 'POST',
        headers: {
          'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
          'X-Idempotency-Key': `test_${i}_${Date.now()}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          customer_id: '31TgvwFzi3rstV0DEDzQtuBfwFR',
          destination_id: '31TgvySz1ARnqMZUdbuxykqqxGV',
          source_asset: 'USD',
          source_network_id: 'fiat',
          destination_asset: 'USDC',
          destination_network_id: 'ethereum-mainnet',
          amount: {
            value: '10.00',
            asset: 'USD'
          }
        })
      })
    );
  }
  
  const results = await Promise.allSettled(transactions);
  console.log(`${results.filter(r => r.status === 'fulfilled').length} succeeded`);
}

Python

import asyncio
import aiohttp
import uuid

async def test_transaction_volume():
    async with aiohttp.ClientSession() as session:
        tasks = []
        
        for i in range(10):
            task = session.post(
                'https://api.platform.sandbox.dakota.xyz/transactions/one-off',
                headers={
                    'X-API-Key': 'AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=',
                    'X-Idempotency-Key': str(uuid.uuid4()),
                    'Content-Type': 'application/json'
                },
                json={
                    'customer_id': '31TgvwFzi3rstV0DEDzQtuBfwFR',
                    'destination_id': '31TgvySz1ARnqMZUdbuxykqqxGV',
                    'source_asset': 'USD',
                    'source_network_id': 'fiat',
                    'destination_asset': 'USDC',
                    'destination_network_id': 'ethereum-mainnet',
                    'amount': {
                        'value': '10.00',
                        'asset': 'USD'
                    }
                }
            )
            tasks.append(task)
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        succeeded = [r for r in results if not isinstance(r, Exception)]
        
        print(f'{len(succeeded)} transactions succeeded')

# Run the test
asyncio.run(test_transaction_volume())

package main

import (
    "bytes"
    "fmt"
    "net/http"
    "sync"
    "github.com/google/uuid"
)

func main() {
    client := &http.Client{}
    var wg sync.WaitGroup
    successCount := 0
    mu := sync.Mutex{}
    
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            
            body := bytes.NewBufferString(`{
                "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
                "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
                "source_asset": "USD",
                "source_network_id": "fiat",
                "destination_asset": "USDC",
                "destination_network_id": "ethereum-mainnet",
                "amount": {
                    "value": "10.00",
                    "asset": "USD"
                }
            }`)
            
            req, _ := http.NewRequest("POST", "https://api.platform.sandbox.dakota.xyz/transactions/one-off", body)
            req.Header.Add("X-API-Key", "AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=")
            req.Header.Add("X-Idempotency-Key", uuid.New().String())
            req.Header.Add("Content-Type", "application/json")
            
            resp, err := client.Do(req)
            if err == nil && resp.StatusCode < 400 {
                mu.Lock()
                successCount++
                mu.Unlock()
            }
            if resp != nil {
                resp.Body.Close()
            }
        }(i)
    }
    
    wg.Wait()
    fmt.Printf("%d transactions succeeded\n", successCount)
}

Rust

use reqwest::header::{HeaderMap, HeaderValue};
use uuid::Uuid;
use serde_json::json;
use tokio::task::JoinSet;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let mut tasks = JoinSet::new();
    
    for i in 0..10 {
        let client_clone = client.clone();
        tasks.spawn(async move {
            let mut headers = HeaderMap::new();
            headers.insert("X-API-Key", HeaderValue::from_static("AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc="));
            headers.insert("X-Idempotency-Key", HeaderValue::from_str(&Uuid::new_v4().to_string()).unwrap());
            headers.insert("Content-Type", HeaderValue::from_static("application/json"));
            
            let body = json!({
                "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
                "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
                "source_asset": "USD",
                "source_network_id": "fiat",
                "destination_asset": "USDC",
                "destination_network_id": "ethereum-mainnet",
                "amount": {
                    "value": "10.00",
                    "asset": "USD"
                }
            });
            
            client_clone
                .post("https://api.platform.sandbox.dakota.xyz/transactions/one-off")
                .headers(headers)
                .json(&body)
                .send()
                .await
                .is_ok()
        });
    }
    
    let mut success_count = 0;
    while let Some(result) = tasks.join_next().await {
        if result.unwrap_or(false) {
            success_count += 1;
        }
    }
    
    println!("{} transactions succeeded", success_count);
    Ok(())
}

Java

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;
import java.time.Duration;

public class DakotaTransactionVolumeTest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        CompletableFuture<Integer>[] futures = IntStream.range(0, 10)
            .mapToObj(i -> CompletableFuture.supplyAsync(() -> {
                try {
                    String body = """
                        {
                          "customer_id": "31TgvwFzi3rstV0DEDzQtuBfwFR",
                          "destination_id": "31TgvySz1ARnqMZUdbuxykqqxGV",
                          "source_asset": "USD",
                          "source_network_id": "fiat",
                          "destination_asset": "USDC",
                          "destination_network_id": "ethereum-mainnet",
                          "amount": {
                            "value": "10.00",
                            "asset": "USD"
                          }
                        }
                        """;
                    
                    HttpRequest request = HttpRequest.newBuilder()
                        .uri(URI.create("https://api.platform.sandbox.dakota.xyz/transactions/one-off"))
                        .header("X-API-Key", "AHGlPZaxDSMz8Wf1l8VRH4ObdbHiKsWFWnmRyHtiwAc=")
                        .header("X-Idempotency-Key", UUID.randomUUID().toString())
                        .header("Content-Type", "application/json")
                        .POST(HttpRequest.BodyPublishers.ofString(body))
                        .build();
                        
                    HttpResponse<String> response = client.send(request, 
                        HttpResponse.BodyHandlers.ofString());
                        
                    return response.statusCode() < 400 ? 1 : 0;
                } catch (Exception e) {
                    return 0;
                }
            }, executor))
            .toArray(CompletableFuture[]::new);
        
        int successCount = CompletableFuture.allOf(futures)
            .thenApply(v -> IntStream.range(0, futures.length)
                .map(i -> futures[i].join())
                .sum())
            .get();
        
        System.out.println(successCount + " transactions succeeded");
        executor.shutdown();
    }
}

Production Readiness

Pre-Launch Checklist

Before switching to production:

All sandbox tests passing
Error handling comprehensive
Webhook endpoints secured and tested
Rate limiting handled gracefully
Logging and monitoring in place
Security review completed
Backup/recovery procedures tested

Migration to Production

Update Configuration
- Change base URL to https://api.platform.dakota.xyz
- Replace development API keys with production keys
- Update webhook URLs if needed

Environment Variables

DAKOTA_API_KEY=your_production_api_key
DAKOTA_BASE_URL=https://api.platform.dakota.xyz
DAKOTA_PUBLIC_KEY=your_production_webhook_public_key

Gradual Rollout
- Start with small transaction amounts
- Monitor error rates closely
- Have rollback plan ready

Monitoring and Debugging

Logging Best Practices

// Log all API calls
logger.info('Dakota Platform API call', {
  method: 'POST',
  endpoint: '/accounts/onramp', 
  customer_id: '31Tgw0zSyDVo4Az66kmzUjMuwxx',
  crypto_asset: 'USDC'
});

// Log webhook events
logger.info('Webhook received', {
  event: event.event,
  webhook_id: event.id,
  data: event.data
});

Debug Mode

Enable detailed request/response logging:

const dakota = new DakotaSDK({
  baseURL: 'https://api.platform.sandbox.dakota.xyz',
  apiKey: 'your-api-key',
  debug: true // Logs all HTTP requests/responses
});

Common Issues and Solutions

Issue: Webhooks Not Received

Solution: Check webhook endpoint accessibility and response codes

Issue: Transactions Stuck in Processing

Solution: In development, check transaction status via API; may be waiting for simulated processing

Issue: KYB Never Completes

Solution: Use test email patterns or check KYB provider status via API

Issue: Rate Limits Hit Quickly

Solution: Implement exponential backoff and request queuing

Next Steps

After thorough testing:

Authentication - Review production security practices
Customer Onboarding - Set up production KYB flows
Transactions - Process real transactions
Webhooks - Configure production webhook endpoints

API Reference

For testing-specific documentation, see:

Sandbox Environment Reference - Sandbox-specific behaviors
Test Data Reference - Available test scenarios
Error Simulation Reference - Triggering specific errors

Documentation

Authentication

Developers

​Sandbox Environment

​Getting Started

​1. Create Sandbox Account

​2. Sandbox Limitations

​Testing KYB Onboarding

​Sandbox KYB Behavior

​KYB Test Scenarios

​Testing Transactions

​Transaction Test Cases

​Successful Onramp

​Failed Transaction (Insufficient Funds)

​Simulated Processing Times

​Webhook Testing

​Test Webhook Events

​Webhook Testing Tools

​ngrok for Local Development

​Webhook.site for Quick Testing

​Integration Testing Checklist

​Authentication

​Customer Management

​Transaction Processing

​Webhook Handling

​Error Simulation

​Force Specific Errors

​Transaction Errors

​KYB Errors

​Load Testing

​Rate Limit Testing

​Transaction Volume Testing

​Production Readiness

​Pre-Launch Checklist

​Migration to Production

​Monitoring and Debugging

​Logging Best Practices

​Debug Mode

​Common Issues and Solutions

​Issue: Webhooks Not Received

​Issue: Transactions Stuck in Processing

​Issue: KYB Never Completes

​Issue: Rate Limits Hit Quickly

​Next Steps

​API Reference

Sandbox Environment

Getting Started

1. Create Sandbox Account

2. Sandbox Limitations

Testing KYB Onboarding

Sandbox KYB Behavior

KYB Test Scenarios

Testing Transactions

Transaction Test Cases

Successful Onramp

Failed Transaction (Insufficient Funds)

Simulated Processing Times

Webhook Testing

Test Webhook Events

Webhook Testing Tools

ngrok for Local Development

Webhook.site for Quick Testing

Integration Testing Checklist

Authentication

Customer Management

Transaction Processing

Webhook Handling

Error Simulation

Force Specific Errors

Transaction Errors

KYB Errors

Load Testing

Rate Limit Testing

Transaction Volume Testing

Production Readiness

Pre-Launch Checklist

Migration to Production

Monitoring and Debugging

Logging Best Practices

Debug Mode

Common Issues and Solutions

Issue: Webhooks Not Received

Issue: Transactions Stuck in Processing

Issue: KYB Never Completes

Issue: Rate Limits Hit Quickly

Next Steps

API Reference