Rate Limits

Overview

Transaction API implements rate limiting to ensure fair usage and system stability. Different endpoints have different rate limits based on their resource requirements.

Rate Limit Tiers

Authentication

5 requests/minute

/auth/register
/auth/login
/auth/verify-email
/auth/resend-verification

Payment Creation

10 requests/minute

/payment/create
/payment/select-crypto

Other Endpoints

100 requests/minute

All other API endpoints

Rate Limit Headers

All API responses include rate limit information in the headers:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1640995200

integer

Maximum requests allowed per window

integer

Number of requests remaining in current window

integer

Unix timestamp when the rate limit resets

Rate Limit Exceeded

When you exceed the rate limit, you’ll receive a 429 Too Many Requests response:

{
  "success": false,
  "error": {
    "status": 429,
    "code": "RATE_LIMITED",
    "message": "Too many requests"
  },
  "data": null
}

Best Practices

Implement Exponential Backoff

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        // Rate limited - wait and retry
        const retryAfter = response.headers.get('Retry-After') || Math.pow(2, attempt);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        continue;
      }
      
      return response;
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
    }
  }
}

Monitor Rate Limit Usage

function checkRateLimit(response) {
  const limit = parseInt(response.headers.get('X-RateLimit-Limit'));
  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
  const reset = parseInt(response.headers.get('X-RateLimit-Reset'));
  
  console.log(`Rate limit: ${remaining}/${limit} remaining`);
  console.log(`Resets at: ${new Date(reset * 1000)}`);
  
  if (remaining < 10) {
    console.warn('Rate limit nearly exceeded!');
  }
}

Batch Operations

Instead of making multiple individual requests, batch operations when possible:

// ❌ Don't do this
for (const customer of customers) {
  await createCustomer(customer);
}

// ✅ Do this instead
const batchPromises = customers.map(customer => createCustomer(customer));
await Promise.all(batchPromises);

Rate Limit Strategies

For High-Volume Applications

Implement Caching

Cache frequently accessed data to reduce API calls.

Use Webhooks

Subscribe to webhook events instead of polling for updates.

Batch Requests

Combine multiple operations into single requests when possible.

Queue Operations

Use a queue system to manage request timing and avoid bursts.

For Development

Use Sandbox Mode

Test with sandbox mode which has higher rate limits.

Implement Delays

Add delays between requests during development.

Monitor Headers

Always check rate limit headers in your responses.

Monitoring and Alerts

Set Up Monitoring

// Example monitoring setup
class RateLimitMonitor {
  constructor() {
    this.usage = new Map();
  }
  
  trackRequest(endpoint, headers) {
    const limit = parseInt(headers.get('X-RateLimit-Limit'));
    const remaining = parseInt(headers.get('X-RateLimit-Remaining'));
    const reset = parseInt(headers.get('X-RateLimit-Reset'));
    
    this.usage.set(endpoint, {
      limit,
      remaining,
      reset,
      lastChecked: Date.now()
    });
  }
  
  getUsage(endpoint) {
    return this.usage.get(endpoint);
  }
  
  isNearLimit(endpoint, threshold = 0.8) {
    const usage = this.getUsage(endpoint);
    if (!usage) return false;
    
    return usage.remaining / usage.limit < (1 - threshold);
  }
}

Alert Configuration

Set up alerts when approaching rate limits:

if (rateLimitMonitor.isNearLimit('payment/create', 0.9)) {
  console.warn('Payment creation rate limit at 90%');
  // Send alert to monitoring system
}

Common Scenarios

E-commerce Checkout

Scenario: High-volume payment processingSolution:

Use webhooks instead of polling payment status
Implement request queuing
Cache product and price data

Mobile App Integration

Scenario: Frequent API calls from mobile devicesSolution:

Implement local caching
Batch multiple operations
Use background sync

Analytics Dashboard

Scenario: Real-time data fetching for dashboardsSolution:

Use WebSocket connections
Implement data aggregation
Cache dashboard data

Rate Limit Increases

For applications requiring higher rate limits:

Contact Support: Reach out to our support team with your use case
Provide Metrics: Share your current usage patterns and requirements
Business Justification: Explain why higher limits are needed
Implementation Plan: Show how you’ll handle the increased volume

Enterprise Plans: Higher rate limits are available for enterprise customers. Contact sales for more information.

Getting started

Essentials

Integration

Overview

Rate Limit Tiers

Authentication

Payment Creation

Other Endpoints

Rate Limit Headers

Rate Limit Exceeded

Best Practices

Implement Exponential Backoff

Monitor Rate Limit Usage

Batch Operations

Rate Limit Strategies

For High-Volume Applications

For Development

Monitoring and Alerts

Set Up Monitoring

Alert Configuration

Common Scenarios

Rate Limit Increases

​Overview

​Rate Limit Tiers

Authentication

Payment Creation

Other Endpoints

​Rate Limit Headers

​Rate Limit Exceeded

​Best Practices

​Implement Exponential Backoff

​Monitor Rate Limit Usage

​Batch Operations

​Rate Limit Strategies

​For High-Volume Applications

​For Development

​Monitoring and Alerts

​Set Up Monitoring

​Alert Configuration

​Common Scenarios

​Rate Limit Increases

Overview

Rate Limit Tiers

Rate Limit Headers

Rate Limit Exceeded

Best Practices

Implement Exponential Backoff

Monitor Rate Limit Usage

Batch Operations

Rate Limit Strategies

For High-Volume Applications

For Development

Monitoring and Alerts

Set Up Monitoring

Alert Configuration

Common Scenarios

Rate Limit Increases