Error Codes

{
  "error": {
    "code": "invalid_api_key",
    "message": "The API key provided is invalid or has been revoked.",
    "status": 401,
    "details": {
      "api_key_prefix": "un_xxx..."
    }
  }
}

# Correct format: Include API key in Authorization header
curl -X POST "https://www.unosend.co/api/v1/emails" \
  -H "Authorization: Bearer un_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"from": "hello@yourdomain.com", "to": "user@example.com", "subject": "Test", "html": "<p>Hello</p>"}'

{
  "error": {
    "code": "validation_error",
    "message": "Request validation failed",
    "status": 400,
    "details": {
      "errors": [
        {
          "field": "to",
          "message": "must be a valid email address",
          "value": "not-an-email"
        },
        {
          "field": "subject",
          "message": "is required",
          "value": null
        }
      ]
    }
  }
}

const response = await fetch('https://www.unosend.co/api/v1/emails', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
});

if (response.status === 400) {
  const error = await response.json();
  
  if (error.error.code === 'validation_error') {
    // Log each field error
    error.error.details.errors.forEach((e: any) => {
      console.error(`Field '${e.field}': ${e.message}`);
    });
  }
}

{
  "error": {
    "code": "email_not_found",
    "message": "Email with ID 'em_abc123' not found",
    "status": 404,
    "details": {
      "email_id": "em_abc123"
    }
  }
}

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Retry after 60 seconds.",
    "status": 429,
    "details": {
      "retry_after": 60,
      "limit": 100,
      "remaining": 0,
      "reset_at": "2024-01-15T10:30:00Z"
    }
  }
}

interface UnosendError {
  error: {
    code: string;
    message: string;
    status: number;
    details?: Record<string, any>;
  };
}

async function sendEmail(payload: EmailPayload): Promise<EmailResponse> {
  const response = await fetch('https://www.unosend.co/api/v1/emails', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });
  
  if (!response.ok) {
    const error: UnosendError = await response.json();
    
    switch (error.error.code) {
      case 'invalid_api_key':
      case 'missing_api_key':
        throw new Error('Authentication failed. Check your API key.');
        
      case 'validation_error':
        const fields = error.error.details?.errors
          ?.map((e: any) => `${e.field}: ${e.message}`)
          .join(', ');
        throw new Error(`Validation failed: ${fields}`);
        
      case 'rate_limit_exceeded':
        const retryAfter = error.error.details?.retry_after || 60;
        // Implement retry logic
        await sleep(retryAfter * 1000);
        return sendEmail(payload); // Retry once
        
      case 'domain_not_verified':
        throw new Error('Verify your domain before sending emails.');
        
      case 'quota_exceeded':
        throw new Error('Monthly email quota exceeded. Upgrade your plan.');
        
      case 'internal_server_error':
      case 'service_unavailable':
        // Retry with exponential backoff
        throw new Error('Service temporarily unavailable. Please retry.');
        
      default:
        throw new Error(error.error.message);
    }
  }
  
  return response.json();
}

import requests
import time

class UnosendError(Exception):
    def __init__(self, code, message, status, details=None):
        self.code = code
        self.message = message
        self.status = status
        self.details = details or {}
        super().__init__(message)

def send_email(payload):
    api_key = "un_xxxxxxxx"
    
    response = requests.post(
        "https://www.unosend.co/api/v1/emails",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json=payload
    )
    
    if not response.ok:
        error = response.json()["error"]
        
        if error["code"] == "rate_limit_exceeded":
            retry_after = error.get("details", {}).get("retry_after", 60)
            time.sleep(retry_after)
            return send_email(payload)  # Retry
        
        if error["code"] == "validation_error":
            errors = error.get("details", {}).get("errors", [])
            fields = ", ".join([f"{e['field']}: {e['message']}" for e in errors])
            raise UnosendError(
                error["code"],
                f"Validation failed: {fields}",
                error["status"],
                error.get("details")
            )
        
        raise UnosendError(
            error["code"],
            error["message"],
            error["status"],
            error.get("details")
        )
    
    return response.json()

# Check HTTP status code and response
response=$(curl -s -w "\n%{http_code}" -X POST "https://www.unosend.co/api/v1/emails" \
  -H "Authorization: Bearer un_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"from": "hello@yourdomain.com", "to": "user@example.com", "subject": "Test", "html": "<p>Hello</p>"}')

status=$(echo "$response" | tail -n1)
body=$(echo "$response" | sed '$d')

if [ "$status" -ge 400 ]; then
  echo "Error ($status): $body"
else
  echo "Success: $body"
fi