Rate Limit Optimization

Want to send more emails faster without hitting rate limits? Here’s how to optimize your API usage and handle rate limits like a pro.

🚀 Understanding Rate Limits

Default limit

Most endpoints allow 100 requests per minute per IP address, counted separately for each endpoint. Authentication endpoints are stricter. The Rate limiting page lists every limit and explains the headers and the 429 response.

Rate Limit Headers

Every response includes these headers:

X-RateLimit-Limit: 50        // Max requests per window
X-RateLimit-Remaining: 23   // Requests left in current window
X-RateLimit-Reset: 1640995200  // Unix timestamp when window resets

⚡ Optimization Strategies

1. Batch Your Requests

Instead of sending emails one by one:

// ❌ Bad: 100 individual requests
for (const email of emailList) {
  await sendEmail(email); // 100 API calls
}

// ✅ Good: Batch requests
const batchSize = 10;
for (let i = 0; i < emailList.length; i += batchSize) {
  const batch = emailList.slice(i, i + batchSize);
  await sendBatchEmails(batch); // 10 API calls
}

2. Use Connection Pooling

Keep connections alive:

// Reuse HTTP connections
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 10,
  maxFreeSockets: 5
});

const client = axios.create({
  baseURL: 'https://api.xem.email',
  httpsAgent: agent,
  timeout: 30000
});

3. Implement Caching

Cache frequently accessed data:

const cache = new Map();

const getCachedData = async (key, ttl = 300000) => {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.timestamp < ttl) {
    return cached.data;
  }
  
  const data = await fetchFromAPI(key);
  cache.set(key, { data, timestamp: Date.now() });
  return data;
};

🔄 Rate Limit Handling

Exponential Backoff

const sendWithBackoff = async (email, maxRetries = 5) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await sendEmail(email);
    } catch (error) {
      if (error.status === 429) {
        const waitTime = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
        console.log(`Rate limited. Waiting ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
      throw error;
    }
  }
  throw new Error('Max retries exceeded');
};

Jitter Implementation

Add randomness to prevent thundering herd:

const addJitter = (baseDelay) => {
  const jitter = Math.random() * 0.1 * baseDelay; // 10% jitter
  return baseDelay + jitter;
};

const waitWithJitter = async (delay) => {
  const jitteredDelay = addJitter(delay);
  await new Promise(resolve => setTimeout(resolve, jitteredDelay));
};

📊 Monitoring & Analytics

Track Rate Limit Usage

class RateLimitTracker {
  constructor() {
    this.usage = new Map();
  }

  trackRequest(endpoint) {
    const now = Date.now();
    const window = Math.floor(now / 60000); // 1-minute windows
    
    if (!this.usage.has(endpoint)) {
      this.usage.set(endpoint, new Map());
    }
    
    const endpointUsage = this.usage.get(endpoint);
    endpointUsage.set(window, (endpointUsage.get(window) || 0) + 1);
  }

  getUsage(endpoint) {
    const now = Date.now();
    const window = Math.floor(now / 60000);
    return this.usage.get(endpoint)?.get(window) || 0;
  }
}

Predictive Scaling

const predictRateLimit = (endpoint, currentUsage) => {
  const limits = {
    'POST:/email': 50,
    'GET:/api/v1/analytics': 100
  };
  
  const limit = limits[endpoint];
  const remaining = limit - currentUsage;
  const timeToReset = 60 - (Date.now() % 60000) / 1000;
  
  return {
    remaining,
    timeToReset,
    canSend: remaining > 0
  };
};

🎯 Best Practices

1. Pre-warm Your Sending

// Gradually increase sending volume
const warmUpSending = async (targetVolume, days = 7) => {
  const dailyIncrease = targetVolume / days;
  
  for (let day = 1; day <= days; day++) {
    const volume = Math.floor(dailyIncrease * day);
    await sendBatch(volume);
    await sleep(24 * 60 * 60 * 1000); // Wait 24 hours
  }
};

2. Use Multiple SMTP Providers

const smtpProviders = [
  { name: 'gmail', config: gmailConfig },
  { name: 'sendgrid', config: sendgridConfig },
  { name: 'mailgun', config: mailgunConfig }
];

const sendWithFallback = async (email) => {
  for (const provider of smtpProviders) {
    try {
      return await sendWithProvider(email, provider);
    } catch (error) {
      console.log(`Provider ${provider.name} failed:`, error.message);
      continue;
    }
  }
  throw new Error('All providers failed');
};

3. Optimize Request Size

// Compress large payloads
const compressPayload = (data) => {
  return gzip(JSON.stringify(data));
};

// Use streaming for large files
const uploadLargeFile = async (filePath) => {
  const stream = fs.createReadStream(filePath);
  return await uploadStream(stream);
};

🚨 Common Pitfalls

1. Ignoring Rate Limit Headers

// ❌ Bad: Not checking headers
const response = await sendEmail(email);

// ✅ Good: Check and respect headers
const response = await sendEmail(email);
const remaining = response.headers.get('X-RateLimit-Remaining');
if (parseInt(remaining) < 5) {
  console.warn('Rate limit almost reached!');
}

2. Synchronous Processing

// ❌ Bad: Blocking on each email
for (const email of emails) {
  await sendEmail(email); // Blocks until complete
}

// ✅ Good: Parallel processing
const promises = emails.map(email => sendEmail(email));
await Promise.all(promises);

3. No Error Recovery

// ❌ Bad: Fail fast
const sendAll = async (emails) => {
  for (const email of emails) {
    await sendEmail(email); // Stops on first error
  }
};

// ✅ Good: Continue on errors
const sendAll = async (emails) => {
  const results = [];
  for (const email of emails) {
    try {
      const result = await sendEmail(email);
      results.push({ success: true, result });
    } catch (error) {
      results.push({ success: false, error });
    }
  }
  return results;
};

📈 Performance Metrics

Track these metrics to optimize performance:

Requests per second: Target 50+ RPS
Rate limit hits: Keep under 1%
Average response time: Target < 200ms
Error rate: Keep under 0.1%
Throughput: Emails sent per minute

🛠️ Tools & Libraries

Node.js Libraries

npm install axios-retry p-limit bottleneck

Python Libraries

pip install tenacity ratelimit asyncio

Go Libraries

go get github.com/uber-go/ratelimit

📞 Need Help?

If you’re hitting rate limits frequently:

Review your sending patterns - are you batching properly?
Check your SMTP configuration - are you using multiple providers?
Monitor your usage - are you tracking rate limit headers?
Contact support for custom rate limit increases

Support: team@xem.email Community: Discord

Overview

Troubleshooting

Best Practices

Performance

Rate limit optimization