Rate Limits

Rate limits help maintain reliable API performance by controlling how frequently your application can send requests within a given period. Understanding these limits is important when building applications with frequent or high-volume AI operations. When a limit is reached, Synoria may temporarily reject additional requests until capacity becomes available. Design your integration to monitor usage, handle limit responses gracefully, and retry temporary failures with appropriate delays. For demanding workloads, consider batching compatible operations, reducing unnecessary requests, or requesting higher capacity when available. A thoughtful approach to rate limits keeps applications responsive, predictable, and reliable as usage scales.

Monitor Request Usage

Track request activity throughout your application to understand usage patterns and identify potential limits before they affect production workflows.

let requestCount = 0;

async function makeRequest(request) {
  requestCount++;

  console.log(`Requests made: ${requestCount}`);

  return await request();
}

export { makeRequest };

Handle Limit Responses

When Synoria returns a rate limit response, avoid immediately sending another request. Wait for an appropriate interval before retrying the operation.

async function handleRateLimit(request, retryAfter = 1000) {
  try {
    return await request();
  } catch (error) {
    if (error.status !== 429) {
      throw error;
    }

    console.log("Rate limit reached.");

    await new Promise(resolve =>
      setTimeout(resolve, retryAfter)
    );

    return await request();
  }
}

Use Exponential Backoff

Repeated failures should use progressively longer delays between attempts. Exponential backoff reduces request pressure and gives the service additional time to recover.

async function withBackoff(request, maxAttempts = 4) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await request();
    } catch (error) {
      if (
        error.status !== 429 ||
        attempt === maxAttempts - 1
      ) {
        throw error;
      }

      const delay = 1000 * 2 ** attempt;

      await new Promise(resolve =>
        setTimeout(resolve, delay)
      );
    }
  }
}

Continue Exploring

Build resilient integrations by monitoring usage, spacing requests, and retrying temporary failures responsibly. For high-volume applications, optimize request patterns before increasing capacity.