Rate Limits

// Always check rate limit headers
const response = await fetch('https://api.daimon.email/v1/messages', {
  headers: { 'Authorization': `Bearer ${apiKey}` }
});

const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
const reset = parseInt(response.headers.get('X-RateLimit-Reset'));

if (remaining < 10) {
  console.warn(`Only ${remaining} requests left. Resets at ${new Date(reset * 1000)}`);
}

# Always check rate limit headers
import requests
import time

response = requests.get(
    'https://api.daimon.email/v1/messages',
    headers={'Authorization': f'Bearer {api_key}'}
)

remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
reset = int(response.headers.get('X-RateLimit-Reset', 0))

if remaining < 10:
    print(f"Only {remaining} requests left. Resets at {time.ctime(reset)}")

async function sendWithRetry(inbox_id, message, maxRetries = 3) {
  let attempt = 0;

  while (attempt < maxRetries) {
    try {
      return await client.inboxes.send(inbox_id, message);
    } catch (error) {
      if (error.status === 429) {
        const retryAfter = error.retry_after || Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Waiting ${retryAfter}ms before retry ${attempt + 1}/${maxRetries}`);

        await sleep(retryAfter);
        attempt++;
      } else {
        throw error;
      }
    }
  }

  throw new Error('Max retries exceeded');
}

import time

def send_with_retry(inbox_id, message, max_retries=3):
    attempt = 0

    while attempt < max_retries:
        try:
            return client.inboxes.send(inbox_id, message)
        except DaimonError as e:
            if e.status == 429:
                retry_after = e.retry_after or (2 ** attempt) * 1000
                print(f"Rate limited. Waiting {retry_after}ms before retry {attempt + 1}/{max_retries}")

                time.sleep(retry_after / 1000)
                attempt += 1
            else:
                raise

    raise Exception('Max retries exceeded')

// Adaptive polling with exponential backoff
let pollInterval = 5000;  // Start at 5 seconds
const maxInterval = 60000;  // Max 1 minute
const minInterval = 5000;   // Min 5 seconds

async function pollMessages() {
  const messages = await client.messages.list(inbox_id);

  if (messages.length > 0) {
    // Messages found, reset to fast polling
    pollInterval = minInterval;
    processMessages(messages);
  } else {
    // No messages, slow down
    pollInterval = Math.min(pollInterval * 1.5, maxInterval);
  }

  setTimeout(pollMessages, pollInterval);
}

# Adaptive polling with exponential backoff
import time

poll_interval = 5  # Start at 5 seconds
max_interval = 60  # Max 1 minute
min_interval = 5   # Min 5 seconds

def poll_messages():
    global poll_interval

    messages = client.messages.list(inbox_id)

    if messages:
        # Messages found, reset to fast polling
        poll_interval = min_interval
        process_messages(messages)
    else:
        # No messages, slow down
        poll_interval = min(poll_interval * 1.5, max_interval)

    time.sleep(poll_interval)
    poll_messages()

const caps = await client.account.capabilities();

console.log('Send usage:', caps.usage.sends_today, '/', caps.limits.sends_per_day);
console.log('Inbox count:', caps.usage.inboxes, '/', caps.limits.max_inboxes);

caps = client.account.capabilities()

print(f"Send usage: {caps['usage']['sends_today']} / {caps['limits']['sends_per_day']}")
print(f"Inbox count: {caps['usage']['inboxes']} / {caps['limits']['max_inboxes']}")