Documentation

Limites de l'API

Bonnes pratiques et recommandations pour l'utilisation de l'API Kiwisocial.

Vue d'ensemble

L'API Kiwisocial est conçue pour offrir une expérience fluide et performante. Pour garantir la qualité du service pour tous les utilisateurs, nous recommandons de suivre les bonnes pratiques décrites ci-dessous.

Note : Actuellement, l'API Kiwisocial ne dispose pas de limites de taux strictes, mais un usage responsable est attendu.

Bonnes pratiques

Optimisation des requêtes

Pagination

Utilisez la pagination pour récupérer les données par lots :

Mise en cache

Implémentez un système de cache pour réduire les requêtes :

Requêtes groupées

Évitez les requêtes multiples inutiles :

Gestion des erreurs

Codes de réponse HTTP

Code Action recommandée
200 Succès - Traiter les données normalement
204 Aucune donnée - Afficher un message approprié à l'utilisateur
400 Requête invalide - Vérifier les paramètres envoyés
401 Non autorisé - Rafraîchir le token ou redemander une connexion
402 Identifiants incorrects - Vérifier les credentials
500 Erreur serveur - Réessayer avec un délai exponentiel

Stratégie de retry

En cas d'erreur serveur (500), implémentez une stratégie de réessai :

// Exemple de stratégie avec délai exponentiel
function retryRequest(url, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return makeRequest(url);
        } catch (error) {
            if (error.code !== 500 || i === maxRetries - 1) {
                throw error;
            }
            // Délai exponentiel : 1s, 2s, 4s
            wait(Math.pow(2, i) * 1000);
        }
    }
}

Limites de contenu

Longueur des messages

Type Limite
Publication (post) 600 caractères
Message privé 3000 caractères
Bio utilisateur 150 caractères

Fichiers médias

Recommandations par fonctionnalité

Fil d'actualité

Messagerie

Notifications

Recherche

Sécurité

Protection des tokens

Validation des données

Monitoring et logs

Logs applicatifs

Implémentez un système de logging pour :

Métriques recommandées

Exemple d'implémentation

Client API avec bonnes pratiques

class KiwisocialAPI {
    constructor() {
        this.baseURL = 'https://kiwisocial.eu/mobile_api/';
        this.token = null;
        this.cache = new Map();
        this.requestQueue = [];
    }

    // Gestion du cache
    getCached(key, maxAge = 300000) { // 5 minutes
        const cached = this.cache.get(key);
        if (cached && Date.now() - cached.timestamp < maxAge) {
            return cached.data;
        }
        return null;
    }

    setCache(key, data) {
        this.cache.set(key, {
            data: data,
            timestamp: Date.now()
        });
    }

    // Requête avec retry
    async request(endpoint, options = {}) {
        const maxRetries = 3;
        let lastError;

        for (let i = 0; i < maxRetries; i++) {
            try {
                const response = await fetch(
                    this.baseURL + endpoint,
                    {
                        ...options,
                        headers: {
                            'Content-Type': 'application/json',
                            ...options.headers
                        }
                    }
                );

                if (!response.ok) {
                    if (response.status === 401) {
                        // Rafraîchir le token
                        await this.refreshToken();
                        continue;
                    }
                    throw new Error(`HTTP ${response.status}`);
                }

                return await response.json();
            } catch (error) {
                lastError = error;
                if (i < maxRetries - 1) {
                    // Délai exponentiel
                    await new Promise(r => 
                        setTimeout(r, Math.pow(2, i) * 1000)
                    );
                }
            }
        }

        throw lastError;
    }

    // Feed avec pagination
    async getFeed(offset = null, pageSize = 20) {
        const cacheKey = `feed_${offset}_${pageSize}`;
        const cached = this.getCached(cacheKey);
        if (cached) return cached;

        const params = new URLSearchParams({
            session_id: this.token,
            page_size: pageSize
        });
        if (offset) params.append('offset', offset);

        const data = await this.request(`feeds?${params}`);
        this.setCache(cacheKey, data);
        return data;
    }
}

Voir aussi