{
  "error": {
    "code": "error_code",
    "message": "Human-readable error message",
    "details": [
      {
        "field": "content",
        "message": "Field-specific error message"
      }
    ],
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "API key is required. Include it in the Authorization header as 'Bearer vfy_...'",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid API key. Check that your key is correct and active.",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "API key has been revoked. Generate a new key from your dashboard.",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "validation_error",
    "message": "Validation failed",
    "details": [
      {
        "field": "content",
        "message": "Content is required"
      }
    ],
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "validation_error",
    "message": "Validation failed",
    "details": [
      {
        "field": "methods.reasoning",
        "message": "Method weight must be between 0 and 1"
      }
    ],
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "validation_error",
    "message": "Validation failed",
    "details": [
      {
        "field": "content",
        "message": "Content exceeds maximum length of 50,000 characters"
      }
    ],
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "rate_limited",
    "message": "Rate limit exceeded. Try again in 60 seconds.",
    "retryAfter": 60,
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "usage_limit_exceeded",
    "message": "Monthly verification limit reached. Upgrade your plan for more verifications.",
    "limit": 1000,
    "used": 1000,
    "resetDate": "2024-02-01T00:00:00Z",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "not_found",
    "message": "Verification ver_abc123 not found",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "not_found",
    "message": "Batch batch_abc123 not found or you don't have access to it",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "provider_error",
    "message": "The LLM provider returned an error. This is usually temporary.",
    "provider": "openai",
    "providerError": "Rate limit exceeded",
    "requestId": "req_abc123"
  }
}

{
  "error": {
    "code": "provider_timeout",
    "message": "The LLM provider took too long to respond. Please retry.",
    "provider": "anthropic",
    "requestId": "req_abc123"
  }
}

import {
  Check,
  CheckError,
  AuthenticationError,
  ValidationError,
  RateLimitError,
  QuotaExceededError,
  NotFoundError,
  ProviderError,
} from '@check/sdk';

const client = new Check({ apiKey: 'vfy_...' });

try {
  const result = await client.verifyAndWait({
    content: 'Your content',
    methods: { reasoning: 1.0 }
  });
} catch (error) {
  if (error instanceof AuthenticationError) {
    // Invalid or missing API key
    console.error('Authentication failed:', error.message);
    // Redirect to login or show API key configuration

  } else if (error instanceof ValidationError) {
    // Invalid request parameters
    console.error('Validation failed:', error.message);
    for (const detail of error.details) {
      console.error(`  ${detail.field}: ${detail.message}`);
    }

  } else if (error instanceof RateLimitError) {
    // Rate limited - wait and retry
    console.error(`Rate limited. Retry after ${error.retryAfter}s`);
    await sleep(error.retryAfter * 1000);
    // Retry the request

  } else if (error instanceof QuotaExceededError) {
    // Monthly quota exceeded
    console.error('Monthly quota exceeded');
    console.error(`Used: ${error.used}/${error.limit}`);
    console.error(`Resets: ${error.resetDate}`);
    // Prompt user to upgrade

  } else if (error instanceof NotFoundError) {
    // Resource not found
    console.error('Resource not found:', error.message);

  } else if (error instanceof ProviderError) {
    // LLM provider error
    console.error(`Provider error (${error.provider}):`, error.message);
    // Usually temporary - retry with backoff

  } else if (error instanceof CheckError) {
    // Generic API error
    console.error('API error:', error.message);
    console.error('Request ID:', error.requestId);

  } else {
    // Network or unexpected error
    console.error('Unexpected error:', error);
  }
}

from check import (
    Check,
    CheckError,
    AuthenticationError,
    ValidationError,
    RateLimitError,
    QuotaExceededError,
    NotFoundError,
    ProviderError,
)
import time

client = Check(api_key="vfy_...")

try:
    result = client.verify_and_wait(
        content="Your content",
        methods={"reasoning": 1.0}
    )
except AuthenticationError as e:
    # Invalid or missing API key
    print(f"Authentication failed: {e.message}")

except ValidationError as e:
    # Invalid request parameters
    print(f"Validation failed: {e.message}")
    for detail in e.details:
        print(f"  {detail['field']}: {detail['message']}")

except RateLimitError as e:
    # Rate limited - wait and retry
    print(f"Rate limited. Retry after {e.retry_after}s")
    time.sleep(e.retry_after)
    # Retry the request

except QuotaExceededError as e:
    # Monthly quota exceeded
    print(f"Monthly quota exceeded: {e.used}/{e.limit}")
    print(f"Resets: {e.reset_date}")

except NotFoundError as e:
    # Resource not found
    print(f"Resource not found: {e.message}")

except ProviderError as e:
    # LLM provider error
    print(f"Provider error ({e.provider}): {e.message}")

except CheckError as e:
    # Generic API error
    print(f"API error: {e.message}")
    print(f"Request ID: {e.request_id}")

except Exception as e:
    # Network or unexpected error
    print(f"Unexpected error: {e}")

async function verifyContent(content: string): Promise<any> {
  const response = await fetch('https://api.check.ai/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ content, methods: { reasoning: 1.0 } }),
  });

  if (!response.ok) {
    const error = await response.json();
    const requestId = error.error?.requestId;

    switch (response.status) {
      case 401:
        throw new Error(`Authentication failed: ${error.error.message}`);

      case 400:
      case 422:
        const details = error.error.details
          ?.map((d: any) => `${d.field}: ${d.message}`)
          .join(', ');
        throw new Error(`Validation error: ${details || error.error.message}`);

      case 429:
        const retryAfter = error.error.retryAfter || 60;
        console.log(`Rate limited. Waiting ${retryAfter}s...`);
        await new Promise(r => setTimeout(r, retryAfter * 1000));
        return verifyContent(content); // Retry

      case 403:
        if (error.error.code === 'usage_limit_exceeded') {
          throw new Error(`Monthly limit reached: ${error.error.used}/${error.error.limit}`);
        }
        throw new Error(`Forbidden: ${error.error.message}`);

      case 404:
        throw new Error(`Not found: ${error.error.message}`);

      case 502:
      case 503:
      case 504:
        // Server errors - retry with backoff
        console.log(`Server error (${response.status}). Retrying...`);
        await new Promise(r => setTimeout(r, 5000));
        return verifyContent(content);

      default:
        throw new Error(`API error (${response.status}): ${error.error.message} [${requestId}]`);
    }
  }

  return response.json();
}

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3,
  baseDelay = 1000
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error: any) {
      const isRetryable = [429, 500, 502, 503, 504].includes(error.status);
      const isLastAttempt = attempt === maxRetries;

      if (!isRetryable || isLastAttempt) {
        throw error;
      }

      // Use retryAfter for 429, otherwise exponential backoff
      const delay = error.retryAfter
        ? error.retryAfter * 1000
        : baseDelay * Math.pow(2, attempt) + Math.random() * 1000;

      console.log(`Attempt ${attempt + 1} failed. Retrying in ${delay}ms...`);
      await new Promise(r => setTimeout(r, delay));
    }
  }
  throw new Error('Unreachable');
}

if (!response.ok) {
  const error = await response.json();
  console.error('API Error', {
    status: response.status,
    code: error.error.code,
    message: error.error.message,
    requestId: error.error.requestId,
    timestamp: new Date().toISOString(),
  });
}