HTTP/1.1 200 OK
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1702648800
Content-Type: application/json

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Rate limit exceeded. Please retry after the specified time.",
    "details": {
      "limit": 100,
      "remaining": 0,
      "reset_at": "2025-12-15T10:31:00Z",
      "retry_after": 60
    },
    "trace_id": "a1b2c3d4e5"
  }
}

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1702648860
Retry-After: 60
Content-Type: application/json

# Check response headers and wait if rate limited
curl -I "https://api.demo.lms.lendfoundry.com/v1/loan-management/search/LN-2024-001/details" \
  -H "Authorization: Bearer YOUR_TOKEN"

const makeRequestWithRetry = async (url, options, maxRetries = 3) => {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);
    
    if (response.status === 429) {
      const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
      console.log(`Rate limited. Waiting ${retryAfter} seconds...`);
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      continue;
    }
    
    return response;
  }
  
  throw new Error('Max retries exceeded');
};

import time
import requests

def make_request_with_retry(url, headers, max_retries=3):
    """Make request with automatic retry on rate limit."""
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        
        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 60))
            print(f"Rate limited. Waiting {retry_after} seconds...")
            time.sleep(retry_after)
            continue
        
        return response
    
    raise Exception("Max retries exceeded")

public HttpResponse<String> makeRequestWithRetry(String url, Map<String, String> headers, int maxRetries) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    for (int attempt = 0; attempt < maxRetries; attempt++) {
        HttpRequest.Builder builder = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET();
        
        headers.forEach(builder::header);
        HttpResponse<String> response = client.send(builder.build(), 
            HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() == 429) {
            String retryAfter = response.headers().firstValue("Retry-After").orElse("60");
            System.out.println("Rate limited. Waiting " + retryAfter + " seconds...");
            Thread.sleep(Integer.parseInt(retryAfter) * 1000);
            continue;
        }
        
        return response;
    }
    
    throw new Exception("Max retries exceeded");
}

import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_retry_session(retries=3, backoff_factor=1):
    """Create requests session with automatic retry."""
    session = requests.Session()
    
    retry = Retry(
        total=retries,
        read=retries,
        connect=retries,
        backoff_factor=backoff_factor,
        status_forcelist=(429, 500, 502, 503, 504),
        respect_retry_after_header=True
    )
    
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)
    
    return session

# Usage
session = create_retry_session()
response = session.get(url, headers=headers)

# ❌ Bad - 10 separate requests
for loan_id in loan_ids:
    response = requests.get(f"/loans/{loan_id}", headers=headers)

# ✅ Good - 1 batch request (if available)
response = requests.post("/loans/batch", 
    json={"loan_ids": loan_ids}, 
    headers=headers
)

from functools import lru_cache
import time

class CachedAPIClient:
    """API client with response caching."""
    
    def __init__(self, base_url, headers, cache_ttl=300):
        self.base_url = base_url
        self.headers = headers
        self.cache = {}
        self.cache_ttl = cache_ttl
    
    def get_loan(self, loan_number):
        """Get loan with caching."""
        cache_key = f"loan_{loan_number}"
        
        # Check cache
        if cache_key in self.cache:
            data, cached_time = self.cache[cache_key]
            if time.time() - cached_time < self.cache_ttl:
                return data
        
        # Fetch from API
        response = requests.get(
            f"{self.base_url}/loan-management/search/{loan_number}/details",
            headers=self.headers
        )
        response.raise_for_status()
        data = response.json()
        
        # Update cache
        self.cache[cache_key] = (data, time.time())
        
        return data

def check_rate_limit_status(response):
    """Extract rate limit info from response headers."""
    from datetime import datetime
    
    limit = int(response.headers.get('X-RateLimit-Limit', 0))
    remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
    reset_timestamp = int(response.headers.get('X-RateLimit-Reset', 0))
    
    if limit > 0:
        usage_percent = ((limit - remaining) / limit) * 100
        reset_at = datetime.fromtimestamp(reset_timestamp)
        
        return {
            "limit": limit,
            "remaining": remaining,
            "reset_at": reset_at,
            "usage_percent": usage_percent
        }
    
    return None

# Usage
response = requests.get(url, headers=headers)
status = check_rate_limit_status(response)

if status:
    print(f"Rate limit: {status['usage_percent']:.1f}% used")
    print(f"Remaining: {status['remaining']} requests")
    print(f"Resets at: {status['reset_at']}")

class RateLimitMonitor:
    """Monitor rate limit usage and alert when high."""
    
    def __init__(self, warning_threshold=0.8):
        self.warning_threshold = warning_threshold
    
    def check_response(self, response):
        """Check response and alert if approaching limit."""
        status = check_rate_limit_status(response)
        
        if status and status['usage_percent'] >= self.warning_threshold * 100:
            self._send_alert(status)
        
        return status
    
    def _send_alert(self, status):
        """Send alert when approaching rate limit."""
        print(f"⚠️  Rate limit warning: {status['usage_percent']:.1f}% used")
        print(f"   Only {status['remaining']} requests remaining")
        # Add your alerting logic here (Slack, email, etc.)

# Usage
monitor = RateLimitMonitor(warning_threshold=0.8)
response = requests.get(url, headers=headers)
monitor.check_response(response)