Error Handling

Copy

• Copy for LLM

  Copy page as Markdown for LLMs
• View as Markdown

  Open this page as Markdown
• Open in ChatGPT

  Get insights from ChatGPT
• Open in Claude

  Get insights from Claude
• Connect to Cursor

  Install MCP server on Cursor
• Connect to VS Code

  Install MCP server on VS Code

{
  "detail": "Error message describing what went wrong",
  "error_code": "SPECIFIC_ERROR_CODE",
  "field_errors": {
    "field_name": ["Field-specific error message"]
  }
}

{
  "detail": "JSON parse error - Expecting value"
}

{
  "detail": "Authentication credentials were not provided."
}

{
  "detail": "You do not have permission to perform this action."
}

{
  "detail": "Not found."
}

{
  "identifier": ["This field is required."],
  "assessment_type": ["Invalid choice."]
}

{
  "detail": "Request was throttled. Expected available in 3600 seconds."
}

async function makeApiCall(url: string) {
  try {
    const response = await fetch(url, {
      headers: {
        'Authorization': `Bearer ${API_TOKEN}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      const error = await response.json();
      
      switch (response.status) {
        case 400:
          throw new ValidationError(error.detail);
        case 401:
          throw new AuthenticationError('Invalid token');
        case 403:
          throw new PermissionError('Insufficient permissions');
        case 404:
          throw new NotFoundError('Resource not found');
        case 429:
          throw new RateLimitError('Rate limit exceeded');
        default:
          throw new APIError(error.detail);
      }
    }

    return await response.json();
  } catch (error) {
    console.error('API Error:', error);
    throw error;
  }
}

import requests
from requests.exceptions import HTTPError

class APIError(Exception):
    pass

class AuthenticationError(APIError):
    pass

class ValidationError(APIError):
    pass

def make_api_call(url):
    try:
        response = requests.get(
            url,
            headers={
                'Authorization': f'Bearer {API_TOKEN}',
                'Content-Type': 'application/json'
            }
        )
        response.raise_for_status()
        return response.json()
        
    except HTTPError as e:
        status_code = e.response.status_code
        error_data = e.response.json()
        
        if status_code == 401:
            raise AuthenticationError('Invalid token')
        elif status_code == 422:
            raise ValidationError(error_data)
        elif status_code == 429:
            # Implement retry logic
            time.sleep(60)
            return make_api_call(url)
        else:
            raise APIError(error_data.get('detail'))

import time
from typing import Optional

def make_request_with_retry(
    url: str,
    max_retries: int = 3,
    backoff_factor: int = 2
) -> Optional[dict]:
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.HTTPError as e:
            status_code = e.response.status_code
            
            # Don't retry client errors (except rate limit)
            if 400 <= status_code < 500 and status_code != 429:
                raise
            
            # Calculate wait time
            wait_time = backoff_factor ** attempt
            
            if attempt < max_retries - 1:
                print(f"Retry {attempt + 1}/{max_retries} after {wait_time}s")
                time.sleep(wait_time)
            else:
                raise

interface ValidationErrorResponse {
  [field: string]: string[];
}

function handleValidationError(errors: ValidationErrorResponse) {
  const formattedErrors = Object.entries(errors).map(
    ([field, messages]) => ({
      field,
      message: messages.join(', ')
    })
  );
  
  // Display errors to user
  formattedErrors.forEach(({ field, message }) => {
    showFieldError(field, message);
  });
}

function logApiError(error, context) {
  console.error({
    timestamp: new Date().toISOString(),
    endpoint: context.url,
    method: context.method,
    status: error.status,
    message: error.message,
    // Don't log: token, user data
  });
}