Error Handling

async function apiCallWithRetry(url, options, maxRetries = 3) {
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, options);
      
      if (response.ok) {
        return await response.json();
      }
      
      // Don't retry client errors (4xx) except rate limits
      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
        const error = await response.json();
        throw new Error(`API Error: ${error.error}`);
      }
      
      // Retry server errors and rate limits
      lastError = new Error(`HTTP ${response.status}`);
      
      // Exponential backoff
      const delay = Math.min(1000 * Math.pow(2, i), 10000);
      await new Promise(resolve => setTimeout(resolve, delay));
      
    } catch (error) {
      lastError = error;
      
      // Network errors - retry
      if (error.name === 'TypeError') {
        const delay = Math.min(1000 * Math.pow(2, i), 10000);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      
      throw error;
    }
  }
  
  throw lastError;
}

// Usage
try {
  const result = await apiCallWithRetry(
    'https://app.safepays.com/api/customer',
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data)
    }
  );
  console.log('Success:', result);
} catch (error) {
  console.error('Failed after retries:', error);
}

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

def api_call_with_retry(
    url: str,
    method: str = 'GET',
    data: Optional[Dict[str, Any]] = None,
    max_retries: int = 3
) -> Dict[str, Any]:
    last_error = None
    
    for attempt in range(max_retries):
        try:
            if method == 'POST':
                response = requests.post(url, json=data)
            else:
                response = requests.get(url, params=data)
            
            # Success
            if response.status_code in range(200, 300):
                return response.json()
            
            # Don't retry client errors (except rate limits)
            if 400 <= response.status_code < 500 and response.status_code != 429:
                error_data = response.json()
                raise Exception(f"API Error: {error_data.get('error', 'Unknown error')}")
            
            # Retry server errors and rate limits
            last_error = f"HTTP {response.status_code}"
            
            # Exponential backoff
            delay = min(2 ** attempt, 10)
            time.sleep(delay)
            
        except requests.exceptions.RequestException as e:
            last_error = str(e)
            # Network error - retry with backoff
            delay = min(2 ** attempt, 10)
            time.sleep(delay)
    
    raise Exception(f"Failed after {max_retries} retries: {last_error}")

# Usage
try:
    result = api_call_with_retry(
        'https://app.safepays.com/api/customer',
        method='POST',
        data={
            'api_key': 'your_api_key',
            'name': 'John Doe',
            'email': 'john@example.com'
        }
    )
    print('Success:', result)
except Exception as e:
    print('Failed:', e)

<?php
function apiCallWithRetry($url, $method = 'GET', $data = null, $maxRetries = 3) {
    $lastError = null;
    
    for ($attempt = 0; $attempt < $maxRetries; $attempt++) {
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $curlError = curl_error($ch);
        curl_close($ch);
        
        // Network error
        if ($response === false) {
            $lastError = "Network error: $curlError";
            sleep(min(pow(2, $attempt), 10));
            continue;
        }
        
        // Success
        if ($httpCode >= 200 && $httpCode < 300) {
            return json_decode($response, true);
        }
        
        // Don't retry client errors (except rate limits)
        if ($httpCode >= 400 && $httpCode < 500 && $httpCode !== 429) {
            $error = json_decode($response, true);
            throw new Exception("API Error: " . ($error['error'] ?? 'Unknown error'));
        }
        
        // Retry server errors and rate limits
        $lastError = "HTTP $httpCode";
        sleep(min(pow(2, $attempt), 10));
    }
    
    throw new Exception("Failed after $maxRetries retries: $lastError");
}

// Usage
try {
    $result = apiCallWithRetry(
        'https://app.safepays.com/api/customer',
        'POST',
        [
            'api_key' => 'your_api_key',
            'name' => 'John Doe',
            'email' => 'john@example.com'
        ]
    );
    echo "Success: " . json_encode($result);
} catch (Exception $e) {
    echo "Failed: " . $e->getMessage();
}
?>