Errors

async function fetchWithRetry(url, options, maxRetries = 3) {
  const retryableStatuses = [429, 500, 502, 503];

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

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

      const problem = await response.json();

      // Check if error is retryable
      if (retryableStatuses.includes(problem.status) && attempt < maxRetries) {
        let delay;

        if (problem.status === 429) {
          // Use Retry-After header if available
          delay = (parseInt(response.headers.get('Retry-After')) || 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 [${problem.request_id}]: ${problem.title} - ${problem.detail}`);

    } 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/cst_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 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_statuses = [429, 500, 502, 503]

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

            if response.ok:
                return response.json()

            problem = response.json()
            status = problem.get('status', response.status_code)

            # Check if error is retryable
            if status in retryable_statuses and attempt < max_retries:
                if status == 429:
                    # Use Retry-After header if available
                    delay = int(response.headers.get('Retry-After', 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
            request_id = problem.get('request_id', 'unknown')
            raise Exception(
                f"API Error [{request_id}]: {problem.get('title')} - {problem.get('detail')}"
            )

        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/cst_123',
        headers={'x-api-key': api_key}
    )
    print('Customer:', customer)
except Exception as e:
    print(f'Request failed after retries: {e}')

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "time"
)

type ProblemDetails struct {
    Type      string `json:"type"`
    Title     string `json:"title"`
    Status    int    `json:"status"`
    Detail    string `json:"detail"`
    RequestID string `json:"request_id"`
}

func fetchWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
    retryableStatuses := map[int]bool{429: true, 500: true, 502: true, 503: true}

    for attempt := 0; attempt <= maxRetries; attempt++ {
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Set("x-api-key", apiKey)

        client := &http.Client{Timeout: 30 * time.Second}
        resp, err := client.Do(req)

        if err != nil {
            // Network error - retry
            if attempt < maxRetries {
                delay := time.Duration(1<<attempt) * time.Second
                fmt.Printf("Network error, retrying in %v\n", delay)
                time.Sleep(delay)
                continue
            }
            return nil, err
        }
        defer resp.Body.Close()

        if resp.StatusCode >= 200 && resp.StatusCode < 300 {
            var result []byte
            json.NewDecoder(resp.Body).Decode(&result)
            return result, nil
        }

        var problem ProblemDetails
        json.NewDecoder(resp.Body).Decode(&problem)

        if retryableStatuses[problem.Status] && attempt < maxRetries {
            var delay time.Duration
            if problem.Status == 429 {
                retryAfter := resp.Header.Get("Retry-After")
                seconds, _ := strconv.Atoi(retryAfter)
                if seconds == 0 {
                    seconds = 60
                }
                delay = time.Duration(seconds) * time.Second
            } else {
                delay = time.Duration(1<<attempt) * time.Second
            }
            fmt.Printf("Retrying in %v (attempt %d/%d)\n", delay, attempt+1, maxRetries)
            time.Sleep(delay)
            continue
        }

        return nil, fmt.Errorf("API Error [%s]: %s - %s",
            problem.RequestID, problem.Title, problem.Detail)
    }

    return nil, fmt.Errorf("max retries exceeded")
}