Error Codes

{
  "code": "error_code",
  "message": "Human-readable error description"
}

{
  "code": "unauthorized",
  "message": "Unauthorized"
}

{
  "code": "invalid_request",
  "message": "Bad Request"
}

{
  "code": "rate_limit_exceeded",
  "message": "Too many requests"
}

{
  "code": "customer_not_found",
  "message": "Customer not found"
}

{
  "code": "duplicate_identifier",
  "message": "Identifier already exists"
}

{
  "code": "limit_reached",
  "message": "Limit of API keys reached"
}

{
  "code": "compliance_check_failed",
  "message": "This wallet address cannot be processed due to compliance restrictions."
}

{
  "code": "bad_gateway",
  "message": "Bad gateway"
}

{
  "code": "internal_server_error",
  "message": "Internal Server Error"
}

const response = await fetch('https://api.platform.dakota.xyz/customers', {
  headers: { 'x-api-key': apiKey }
});

if (!response.ok) {
  const error = await response.json();

  switch (error.code) {
    case 'unauthorized':
      console.log('Check your API key');
      break;
    case 'rate_limit_exceeded':
      const resetSeconds = response.headers.get('X-RateLimit-Reset') || 60;
      await new Promise(r => setTimeout(r, resetSeconds * 1000));
      // Retry request
      break;
    case 'customer_not_found':
      console.log('Customer does not exist');
      break;
    default:
      console.error(`Error: ${error.message}`);
  }
}

async function fetchWithRetry(url, options, maxRetries = 3) {
  const retryableErrors = ['bad_gateway', 'service_unavailable', 'internal_server_error', 'rate_limit_exceeded'];

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);

      if (response.ok) {
        return response.json();
      }

      const error = await response.json();

      // Check if error is retryable
      if (retryableErrors.includes(error.code) && attempt < maxRetries) {
        let delay;

        if (error.code === 'rate_limit_exceeded') {
          // Use rate limit header if available
          delay = (parseInt(response.headers.get('X-RateLimit-Reset')) || 60) * 1000;
        } else {
          // Exponential backoff: 1s, 2s, 4s
          delay = Math.pow(2, attempt) * 1000;
        }

        console.log(`Retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
        await new Promise(r => setTimeout(r, delay));
        continue;
      }

      // Non-retryable error
      throw new Error(`API Error: ${error.code} - ${error.message}`);

    } catch (networkError) {
      // Network errors are retryable
      if (attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Network error, retrying in ${delay}ms`);
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw networkError;
    }
  }
}

// Usage
try {
  const customer = await fetchWithRetry(
    'https://api.platform.dakota.xyz/customers/123',
    { headers: { 'x-api-key': apiKey } }
  );
  console.log('Customer:', customer);
} catch (error) {
  console.error('Request failed after retries:', error.message);
}

import time
import requests
from typing import Optional, Dict, Any

def fetch_with_retry(
    url: str,
    headers: Dict[str, str],
    max_retries: int = 3
) -> Dict[str, Any]:
    """Make API request with exponential backoff retry logic."""

    retryable_errors = ['bad_gateway', 'service_unavailable', 'internal_server_error', 'rate_limit_exceeded']

    for attempt in range(max_retries + 1):
        try:
            response = requests.get(url, headers=headers)

            if response.ok:
                return response.json()

            error = response.json()
            error_code = error.get('code', '')

            # Check if error is retryable
            if error_code in retryable_errors and attempt < max_retries:
                if error_code == 'rate_limit_exceeded':
                    # Use rate limit header if available
                    delay = int(response.headers.get('X-RateLimit-Reset', 60))
                else:
                    # Exponential backoff: 1s, 2s, 4s
                    delay = (2 ** attempt)

                print(f"Retrying in {delay}s (attempt {attempt + 1}/{max_retries})")
                time.sleep(delay)
                continue

            # Non-retryable error
            raise Exception(f"API Error: {error_code} - {error.get('message', 'Unknown error')}")

        except requests.exceptions.RequestException as e:
            # Network errors are retryable
            if attempt < max_retries:
                delay = 2 ** attempt
                print(f"Network error, retrying in {delay}s")
                time.sleep(delay)
                continue
            raise

# Usage
try:
    customer = fetch_with_retry(
        'https://api.platform.dakota.xyz/customers/123',
        headers={'x-api-key': api_key}
    )
    print('Customer:', customer)
except Exception as e:
    print(f'Request failed after retries: {e}')

const response = await fetch('https://api.platform.dakota.xyz/customers', {
  method: 'POST',
  headers: {
    'x-api-key': apiKey,
    'x-idempotency-key': 'unique-request-id',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(customerData)
});