API Usage Limits

Codequiry implements intelligent rate limiting and usage quotas to ensure stable service for all users while preventing abuse.

Security & Authentication

                # Environment variables
CODEQUIRY_API_KEY=your-production-key
CODEQUIRY_DEV_API_KEY=your-development-key

# .gitignore
.env
.env.local
*.key
                

                    

                        Security
                    
                
            

                apikey: your-api-key-here
Accept: application/json
Content-Type: application/json
User-Agent: YourApp/1.0
                

                    

                        Headers
                    
                
            

Rate Limiting Details

Codequiry uses a token bucket algorithm with sliding windows to ensure fair access while allowing burst usage.

Abuse Prevention

Automated systems monitor usage patterns to prevent abuse while maintaining service quality for legitimate users.

Processing Time Guidelines

Understanding typical processing times helps with application design and user expectations.

Implementation Guidelines

Error Handling

        // Robust error handling
async function makeApiRequest(url, options) {
    const maxRetries = 3;
    let attempt = 0;

    while (attempt < maxRetries) {
        try {
            const response = await fetch(url, options);

            if (response.status === 429) {
                // Rate limited - exponential backoff
                const delay = Math.pow(2, attempt) * 1000;
                await new Promise(resolve => setTimeout(resolve, delay));
                attempt++;
                continue;
            }

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            return await response.json();

        } catch (error) {
            attempt++;
            if (attempt === maxRetries) {
                throw error;
            }

            // Linear backoff for other errors
            await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
        }
    }
}
        

            

                Error Handling
            
        
    

Rate Limit Monitoring

        # Monitor rate limits
class RateLimitMonitor:
    def __init__(self):
        self.remaining = None
        self.reset_time = None

    def update_from_headers(self, headers):
        self.remaining = int(headers.get('X-RateLimit-Remaining', 0))
        self.reset_time = int(headers.get('X-RateLimit-Reset', 0))

        # Warn when approaching limit
        if self.remaining < 10:
            print(f"⚠️ Rate limit warning: {self.remaining} requests remaining")

        # Pause if rate limited
        if self.remaining <= 0:
            wait_time = self.reset_time - time.time()
            if wait_time > 0:
                print(f"Rate limited. Waiting {wait_time:.0f} seconds...")
                time.sleep(wait_time)

    def should_throttle(self):
        return self.remaining is not None and self.remaining < 5
        

            

                Monitoring
            
        
    

Usage Analytics

Monitor your API usage and optimize performance with built-in analytics and recommendations.

Support & Resources