Development and Usage Guidelines for Optimal Results

Best Practices

Comprehensive best practices for integrating customs duty calculations securely, efficiently, and reliably into your applications.

View Practices Avoid Anti-patterns

Best Practice Categories

Comprehensive guidelines for successful integration

Security Best Practices

Secure your API integration and protect sensitive data.

Performance Optimization

Optimize your integration for speed and efficiency.

Error Handling

Implement robust error handling for production reliability.

Code Quality

Write maintainable and scalable code for long-term success.

Essential Best Practices

Follow these guidelines for secure, efficient, and reliable integration

SecurityCritical

API Key Management

Store API keys securely and rotate them regularly

Key Tips:

Never expose API keys in client-side code
Use environment variables for storage
Implement key rotation policies
Monitor key usage and access

PerformanceHigh

Caching Strategy

Implement intelligent caching to reduce API calls

Key Tips:

Cache duty rates for 24 hours
Use Redis or similar for distributed caching
Implement cache invalidation strategies
Monitor cache hit rates

ReliabilityHigh

Error Handling

Handle API errors gracefully with retry logic

Key Tips:

Implement exponential backoff for retries
Log all API errors for debugging
Provide user-friendly error messages
Set up monitoring and alerting

ScalabilityMedium

Rate Limiting

Respect API rate limits and implement client-side throttling

Key Tips:

Track API usage and implement throttling
Use queue systems for high-volume requests
Implement circuit breakers for fault tolerance
Monitor rate limit headers

Common Anti-patterns to Avoid

Learn from common mistakes and avoid these integration pitfalls

Hardcoding API Keys

Never hardcode API keys in your source code

Impact:

Security risk

Solution:

Use environment variables and secure key management

No Error Handling

Failing to handle API errors can crash your application

Impact:

Poor user experience

Solution:

Implement comprehensive error handling with fallbacks

Ignoring Rate Limits

Making too many requests can get your API access suspended

Impact:

Service disruption

Solution:

Implement proper rate limiting and request queuing

No Caching

Making redundant API calls wastes resources and slows performance

Impact:

Poor performance

Solution:

Implement intelligent caching for frequently requested data

Best Practice Example

Example of proper error handling and caching implementation

Robust Integration Example

Example with proper error handling, caching, and rate limiting

import { CarapisTax } from '@carapis/tax-sdk';

class CustomsCalculator {
  constructor(apiKey) {
    this.tax = new CarapisTax(apiKey);
    this.cache = new Map();
    this.rateLimiter = new RateLimiter(100, 60000); // 100 requests per minute
  }

  async calculateDuty(params) {
    // Check cache first
    const cacheKey = this.generateCacheKey(params);
    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey);
    }

    // Check rate limit
    if (!this.rateLimiter.canMakeRequest()) {
      throw new Error('Rate limit exceeded');
    }

    try {
      const result = await this.tax.calculate(params);
      
      // Cache the result for 24 hours
      this.cache.set(cacheKey, result);
      setTimeout(() => this.cache.delete(cacheKey), 24 * 60 * 60 * 1000);
      
      return result;
    } catch (error) {
      console.error('Calculation error:', error);
      throw new Error('Failed to calculate customs duty');
    }
  }

  generateCacheKey(params) {
    return JSON.stringify(params);
  }
}

Ready to Build with Best Practices?

Get API Key View API Docs