Limits & Security

API Usage Limits

Two separate limits apply to the API: a request rate limit (how often you may call it) and your check credits (how much analysis you may run). They are independent — the rate limit is the same on every plan, while credits are what your plan actually buys you.

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

The API uses a fixed one-minute window. Your first request opens the window; the counter resets 60 seconds later. There is no burst allowance above the limit and no separate per-endpoint limit — every /api/v1 call draws on the same counter.

Rate limit headers

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