Error Responses

{
  "errors": [
    {
      "code": "ValidationException",
      "status": "422",
      "detail": "The given data was invalid.",
      "meta": {
        "rule": "required",
        "source_field": "name"
      }
    }
  ]
}

{
  "errors": [
    {
      "code": "UnauthorizedException",
      "status": "401",
      "detail": "Access to this endpoint must include an Authorization header."
    }
  ]
}

{
  "errors": [
    {
      "code": "AccessDeniedHttpException",
      "status": "403",
      "detail": "This IP address (192.168.1.100) does not have permission to access the API using these credentials."
    }
  ]
}

{
  "errors": [
    {
      "code": "AccessDeniedHttpException",
      "status": "403",
      "detail": "You do not have permission to access this resource."
    }
  ]
}

{
  "errors": [
    {
      "code": "ValidationException",
      "status": "422",
      "detail": "The name field is required.",
      "meta": {
        "source_field": "name",
        "rule": "required"
      }
    },
    {
      "code": "ValidationException",
      "status": "422",
      "detail": "The memory must be at least 128.",
      "meta": {
        "source_field": "limits.memory",
        "rule": "min"
      }
    }
  ]
}

{
  "errors": [
    {
      "code": "NotFoundHttpException",
      "status": "404",
      "detail": "The requested resource does not exist on the system."
    }
  ]
}

{
  "errors": [
    {
      "code": "ConflictHttpException",
      "status": "409",
      "detail": "This backup is already in a completed state."
    }
  ]
}

{
  "errors": [
    {
      "code": "TooManyRequestsHttpException",
      "status": "429",
      "detail": "Too many requests"
    }
  ]
}

Retry-After: 42
X-RateLimit-Limit: 256
X-RateLimit-Remaining: 0

{
  "errors": [
    {
      "code": "ServiceLimitExceededException",
      "status": "400",
      "detail": "Schedules may not have more than 10 tasks associated with them."
    }
  ]
}

{
  "errors": [
    {
      "code": "HttpException",
      "status": "403",
      "detail": "This server is not currently in a state that allows for a backup to be restored."
    }
  ]
}

{
  "errors": [
    {
      "code": "BadRequestHttpException",
      "status": "400",
      "detail": "The JSON data passed in the request appears to be malformed: Syntax error"
    }
  ]
}

{
  "errors": [
    {
      "code": "BadRequestHttpException",
      "status": "400",
      "detail": "A non-empty \"size\" query parameter must be provided."
    }
  ]
}

{
  "errors": [
    {
      "code": "HttpException",
      "status": "502",
      "detail": "Server must be online in order to send commands."
    }
  ]
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    data = response.json()
    # Process successful response
elif response.status_code == 404:
    print("Resource not found")
elif response.status_code == 429:
    retry_after = response.headers.get('Retry-After')
    print(f"Rate limited. Retry after {retry_after} seconds")
else:
    errors = response.json().get('errors', [])
    for error in errors:
        print(f"Error: {error['detail']}")

try {
  const response = await fetch(url, { headers });
  
  if (!response.ok) {
    const errorData = await response.json();
    const errors = errorData.errors || [];
    
    errors.forEach(error => {
      console.error(`[${error.code}] ${error.detail}`);
      
      if (error.meta) {
        console.error('Field:', error.meta.source_field);
        console.error('Rule:', error.meta.rule);
      }
    });
    
    throw new Error('API request failed');
  }
  
  return await response.json();
} catch (error) {
  console.error('Request error:', error);
}

import time
from requests.exceptions import RequestException

def api_request_with_retry(url, headers, max_retries=3, backoff=2):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)
            
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                time.sleep(retry_after)
                continue
            
            if response.status_code >= 500:
                # Server error, retry with exponential backoff
                if attempt < max_retries - 1:
                    time.sleep(backoff ** attempt)
                    continue
            
            response.raise_for_status()
            return response.json()
            
        except RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(backoff ** attempt)
    
    raise Exception("Max retries exceeded")

type APIError struct {
    Code   string `json:"code"`
    Status string `json:"status"`
    Detail string `json:"detail"`
}

func handleAPIError(statusCode int, errors []APIError) error {
    if len(errors) == 0 {
        return fmt.Errorf("unknown error with status %d", statusCode)
    }
    
    switch errors[0].Code {
    case "NotFoundHttpException":
        return &ResourceNotFoundError{Detail: errors[0].Detail}
    case "AccessDeniedHttpException":
        return &PermissionDeniedError{Detail: errors[0].Detail}
    case "ValidationException":
        return &ValidationError{Errors: errors}
    default:
        return &GenericAPIError{StatusCode: statusCode, Errors: errors}
    }
}