Error Handling

{
  "success": false,
  "error": {
    "code": "INVALID_AMOUNT",
    "message": "Amount must be a positive number",
    "details": {
      "field": "amount",
      "value": "-50.00"
    }
  }
}

async function createPayment(amount, description) {
  try {
    const response = await fetch('https://api.harpoonsms.com/v1/transactions/initialize', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ' + process.env.HARPOON_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ amount, description })
    });

    const data = await response.json();

    if (!response.ok) {
      // Handle specific error codes
      switch (data.error?.code) {
        case 'INVALID_AMOUNT':
          throw new Error('Please enter a valid amount');
        case 'RATE_LIMIT_EXCEEDED':
          // Implement exponential backoff
          await delay(getBackoffDelay(retryCount));
          return createPayment(amount, description);
        case 'INSUFFICIENT_SCOPE':
          throw new Error('API key missing required permissions');
        default:
          throw new Error(data.error?.message || 'Payment creation failed');
      }
    }

    return data.data;
  } catch (error) {
    console.error('Payment error:', error);
    throw error;
  }
}

import requests
from time import sleep

class HarpoonError(Exception):
    def __init__(self, code, message, details=None):
        self.code = code
        self.message = message
        self.details = details
        super().__init__(message)

def create_payment(amount: str, description: str, retries: int = 3):
    for attempt in range(retries):
        response = requests.post(
            'https://api.harpoonsms.com/v1/transactions/initialize',
            headers={
                'Authorization': 'Bearer ' + os.environ['HARPOON_API_KEY'],
                'Content-Type': 'application/json'
            },
            json={'amount': amount, 'description': description}
        )

        data = response.json()

        if response.ok:
            return data['data']

        error = data.get('error', {})
        code = error.get('code')

        # Handle rate limiting with exponential backoff
        if code == 'RATE_LIMIT_EXCEEDED' and attempt < retries - 1:
            sleep(2 ** attempt)
            continue

        raise HarpoonError(
            code=code,
            message=error.get('message', 'Unknown error'),
            details=error.get('details')
        )

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1704715600

function getBackoffDelay(attempt) {
  // Exponential backoff: 1s, 2s, 4s, 8s...
  return Math.min(1000 * Math.pow(2, attempt), 30000);
}

async function requestWithRetry(fn, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 'RATE_LIMIT_EXCEEDED' && attempt < maxRetries - 1) {
        await new Promise(r => setTimeout(r, getBackoffDelay(attempt)));
        continue;
      }
      throw error;
    }
  }
}

{
  "error": {
    "code": "INSUFFICIENT_SCOPE",
    "message": "API key does not have transactions:write scope",
    "details": {
      "required_scope": "transactions:write",
      "available_scopes": ["transactions:read"]
    }
  }
}

{
  "error": {
    "code": "MISSING_REQUIRED_FIELD",
    "message": "Required field 'amount' is missing",
    "details": {
      "field": "amount",
      "location": "body"
    }
  }
}