Limites de Débit

curl --request GET \
  --url https://api.smartbills.io/v1/expenses \
  --header 'Authorization: Bearer VOTRE_CLE_API' \
  --header 'x-tenant-id: 123' \
  --verbose 2>&1 | grep -i "x-ratelimit"

import { SmartbillsClient } from '@smartbills/sdk';

const client = new SmartbillsClient({
  accessToken: 'VOTRE_CLE_API',
  businessId: 123
});

// Lors de requêtes fetch brutes, vérifiér les en-tetes :
const response = await fetch('https://api.smartbills.io/v1/expenses', {
  headers: {
    'Authorization': 'Bearer VOTRE_CLE_API',
    'x-tenant-id': '123'
  }
});

const limit = response.headers.get('X-RateLimit-Limit');
const remaining = response.headers.get('X-RateLimit-Remaining');
const reset = response.headers.get('X-RateLimit-Reset');

console.log(`Limite de débit : ${remaining}/${limit}`);
console.log(`Reinitialisation à : ${new Date(reset * 1000)}`);

if (remaining < limit * 0.1) {
  console.warn('Approche de la limite de débit !');
}

from smartbills import SmartbillsClient
import requests
from datetime import datetime

response = requests.get(
    'https://api.smartbills.io/v1/expenses',
    headers={
        'Authorization': 'Bearer VOTRE_CLE_API',
        'x-tenant-id': '123'
    }
)

limit = int(response.headers.get('X-RateLimit-Limit', 0))
remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
reset = int(response.headers.get('X-RateLimit-Reset', 0))

print(f"Limite de débit : {remaining}/{limit}")
print(f"Reinitialisation à : {datetime.fromtimestamp(reset)}")

if remaining < limit * 0.1:
    print("Attention : Approche de la limite de débit !")

async function makeRequestWithRetry(client, fn, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        const retryAfter = error.retryAfter || Math.pow(2, attempt);
        const waitTime = retryAfter * 1000;

        console.log(`Limite de débit atteinte. Attente de ${retryAfter}s avant le réessai...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }

      throw error;
    }
  }

  throw new Error('Nombre maximum de tentatives depasse');
}

// Utilisation
const expense = await makeRequestWithRetry(client, () =>
  client.expenses.get(12345)
);

import time
from smartbills.errors import SmartbillsRateLimitError

def make_request_with_retry(fn, max_retries=3):
    for attempt in range(max_retries):
        try:
            return fn()
        except SmartbillsRateLimitError as e:
            retry_after = e.retry_after or (2 ** attempt)

            print(f"Limite de débit atteinte. Attente de {retry_after}s avant le réessai...")
            time.sleep(retry_after)
            continue

    raise Exception("Nombre maximum de tentatives depasse")

# Utilisation
expense = make_request_with_retry(lambda: client.expenses.get(12345))