> ## Documentation Index
> Fetch the complete documentation index at: https://docs.smartbills.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Limites de Débit
> Comprendre les politiques de limitation de débit de l'API Smartbills, les en-têtes et les bonnes pratiques
## Aperçu
Pour garantir une utilisation equitable et maintenir des performances optimales, l'API Smartbills implemente une limitation de débit. Cela aide à contrôler le trafic des requêtes entrantes et offre une expérience API fluide et previsible pour tous les utilisateurs.
**Utilisation equitable** : Les limites de débit garantissent qu'aucun utilisateur ne peut monopoliser les ressources de l'API, maintenant un service de qualite pour tous.
## Limites de débit par plan
| Plan | Requêtes par minute | Capacite de pointe | Limite quotidienne |
| ----------------- | ------------------- | ------------------ | ------------------ |
| **Gratuit** | 60 | 60 | 5 000 |
| **Professionnel** | 300 | 300 | 50 000 |
| **Affaires** | 1 000 | 1 000 | 200 000 |
| **Entreprise** | Personnalisé | Personnalisé | Personnalisé |
**Besoin de limites plus elevees ?** Les clients Entreprise peuvent demander des limites de débit personnalisées. Contactez [sales@smartbills.io](mailto:sales@smartbills.io) pour plus de détails.
## En-têtes de limite de débit
Chaque réponse API inclut des informations sur la limite de débit dans les en-têtes :
```http theme={null}
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1704067200
```
Nombre maximum de requêtes autorisées par minute pour votre plan
Nombre de requêtes restantes dans la fenêtre actuelle
Horodatage Unix (en secondes) du moment où la fenêtre de limite de débit se réinitialise
## Réponse de limite de débit dépassée
Lorsque vous depassez la limite de débit, vous recevez une réponse `429 Too Many Requests` :
```http theme={null}
HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 60
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1704067200
```
```json theme={null}
{
"error": {
"code": "RATE_LIMIT_EXCEEDED",
"message": "Limite de débit depassee. Veuillez réessayer plus tard.",
"retryAfter": 60
}
}
```
L'en-tête `Retry-After` indique combien de secondes attendre avant de réessayer.
## Gérer les limites de débit
### Vérifier les en-têtes de limite de débit
Surveillez toujours les en-têtes de limite de débit dans votre application :
```bash cURL theme={null}
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"
```
```javascript JavaScript theme={null}
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 !');
}
```
```python Python theme={null}
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 !")
```
### Implementer un backoff exponentiel
Lorsque vous recevez une erreur 429, implementez un backoff exponentiel :
```javascript JavaScript theme={null}
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)
);
```
```python Python theme={null}
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))
```
## Bonnes pratiques
Mettez en cache les réponses API pour réduire les requêtes redondantes. Utilisez une invalidation de cache basee sur le temps pour les données qui ne changent pas frequemment.
Utilisez la taille de page maximale (100) pour le traitement en lot afin de minimiser le nombre d'appels API. Consultez [Pagination](/fr/api-reference/pagination) pour plus de détails.
Combinez plusieurs opérations en requêtes uniques lorsque des points d'accès en lot sont disponibles (ex. : mise à jour en lot des dépenses).
Utilisez les webhooks pour recevoir des notifications en temps réel au lieu d'interroger l'API pour les changements. Consultez [Webhooks](/fr/api-reference/webhooks) pour les instructions de configuration.
Mettez les requêtes en file d'attente et traitez-les à un débit contrôle pour eviter les rafales qui depassent votre limite de débit.
Suivez vos habitudes d'utilisation de l'API et configurez des alertes lorsque vous approchez des limites de débit.
## Demander des limites plus elevees
Les clients Entreprise peuvent demander des limites de débit personnalisées :
* Courriel : [sales@smartbills.io](mailto:sales@smartbills.io)
* Incluez votre cas d'utilisation, le volume de requêtes prévu et les détails de votre plan actuel
* Délai d'approbation typique : 2-3 jours ouvrables
## Dépannage
1. Optimisez votre code pour réduire les requêtes inutiles
2. Implementez la mise en cache pour les données frequemment accedees
3. Utilisez les webhooks pour remplacer les modèles de polling
4. Regroupez les opérations quand c'est possible
5. Envisagez de mettre à niveau votre plan
Assurez-vous d'utiliser la dernière version de l'API (v1) et vérifiez que votre client HTTP ne supprime pas les en-têtes de réponse.
Vérifiez s'il y à plusieurs instances de votre application en cours d'exécution, des clés API partagées entre les services, ou des scripts automatises utilisant la même clé. Utilisez des clés API séparées pour chaque environnement et service.
**Important** : Les limites de débit sont par clé API. Utiliser la même clé dans plusieurs services partagera la limite de débit.
## Ressources connexes
Utiliser les webhooks au lieu du polling
Gérer les erreurs de limite de débit
Paginer efficacement les résultats
Gérer vos clés API