Error Handling — API Error Codes & Responses

import Ark from 'ark';

const client = new Ark();

try {
  const email = await client.emails.send({
    from: 'hello@yourdomain.com',
    to: ['user@example.com'],
    subject: 'Hello',
    html: '<p>Hello!</p>',
  });
  console.log(`Email sent: ${email.data.id}`);

} catch (error) {
  if (error instanceof Ark.BadRequestError) {
    // Invalid request parameters
    console.log(`Bad request: ${error.message}`);
    console.log(`Error code: ${error.code}`);

  } else if (error instanceof Ark.AuthenticationError) {
    // Invalid or missing API key
    console.log('Authentication failed - check your API key');

  } else if (error instanceof Ark.RateLimitError) {
    // Too many requests - wait and retry
    console.log('Rate limited - slow down requests');
    const retryAfter = error.headers?.['retry-after'];

  } else if (error instanceof Ark.NotFoundError) {
    // Resource not found
    console.log('Resource not found');

  } else if (error instanceof Ark.APIConnectionError) {
    // Network error - safe to retry
    console.log('Network error - retrying...');

  } else if (error instanceof Ark.APIError) {
    // Catch-all for other API errors
    console.log(`API error: ${error.message}`);
  }
}

require "ark_email"

client = ArkEmail::Client.new

begin
  email = client.emails.send_(
    from: "hello@yourdomain.com",
    to: ["user@example.com"],
    subject: "Hello",
    html: "<p>Hello!</p>"
  )
  puts "Email sent: #{email.data.id}"

rescue ArkEmail::Errors::BadRequestError => e
  # Invalid request parameters
  puts "Bad request: #{e.message}"
  puts "Error code: #{e.code}" if e.respond_to?(:code)

rescue ArkEmail::Errors::AuthenticationError
  # Invalid or missing API key
  puts "Authentication failed - check your API key"

rescue ArkEmail::Errors::RateLimitError => e
  # Too many requests - wait and retry
  puts "Rate limited - slow down requests"

rescue ArkEmail::Errors::NotFoundError
  # Resource not found
  puts "Resource not found"

rescue ArkEmail::Errors::APIConnectionError
  # Network error - safe to retry
  puts "Network error - retrying..."

rescue ArkEmail::Errors::APIError => e
  # Catch-all for other API errors
  puts "API error: #{e.message}"
end

import (
    "errors"
    "fmt"
    "github.com/ArkHQ-io/ark-go"
)

client := ark.NewClient()

email, err := client.Emails.Send(ctx, ark.EmailSendParams{
    From:    "hello@yourdomain.com",
    To:      []string{"user@example.com"},
    Subject: "Hello",
    HTML:    ark.String("<p>Hello!</p>"),
})

if err != nil {
    var arkErr *ark.Error
    if errors.As(err, &arkErr) {
        switch arkErr.StatusCode {
        case 400:
            // Invalid request parameters
            fmt.Printf("Bad request: %s\n", arkErr.Message)
        case 401:
            // Invalid or missing API key
            fmt.Println("Authentication failed - check your API key")
        case 429:
            // Too many requests - wait and retry
            fmt.Println("Rate limited - slow down requests")
        case 404:
            // Resource not found
            fmt.Println("Resource not found")
        default:
            // Other API errors
            fmt.Printf("API error %d: %s\n", arkErr.StatusCode, arkErr.Message)
        }
    } else {
        // Network or other error
        fmt.Printf("Error: %v\n", err)
    }
    return
}

fmt.Printf("Email sent: %s\n", email.Data.ID)

import Ark from 'ark-email';

const client = new Ark();

try {
  const email = await client.emails.send({
    from: 'hello@yourdomain.com',
    to: ['user@example.com'],
    subject: 'Hello',
    html: '<p>Hello!</p>',
  });
} catch (error) {
  if (error instanceof Ark.BadRequestError) {
    if (error.code === 'insufficient_balance') {
      console.log('Upgrade your plan at https://arkhq.io/org/billing');
    } else if (error.code === 'billing_not_configured') {
      console.log('Set up billing at https://arkhq.io/org/billing');
    }
  }
}

const client = new Ark({ maxRetries: 5 });  // 5 retries
const client = new Ark({ maxRetries: 0 });  // Disable retries

client = ArkEmail::Client.new(max_retries: 5)  # 5 retries
client = ArkEmail::Client.new(max_retries: 0)  # Disable retries

client := ark.NewClient(option.WithMaxRetries(5))  // 5 retries
client := ark.NewClient(option.WithMaxRetries(0))  // Disable retries