Introdução

function makeApiRequest($url, $data, $token) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer ' . $token
    ]);
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    $responseBody = json_decode($response, true);
    
    if ($httpCode !== 200) {
        switch ($httpCode) {
            case 400:
                error_log("Dados inválidos: " . print_r($responseBody['errors'] ?? [], true));
                break;
            case 401:
                error_log("Token inválido ou expirado");
                break;
            case 429:
                $retryAfter = $responseBody['retry_after'] ?? 60;
                sleep($retryAfter);
                return makeApiRequest($url, $data, $token); // Retry
            case 500:
                error_log("Erro interno do servidor");
                break;
        }
        throw new Exception("Erro API: " . ($responseBody['message'] ?? 'Erro desconhecido'));
    }
    
    return $responseBody;
}

import requests
import time

def make_api_request(url, data, token, max_retries=3):
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }
    
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data)
            
            if response.status_code == 200:
                return response.json()
            
            error = response.json()
            
            if response.status_code == 400:
                print(f"Dados inválidos: {error.get('errors', {})}")
            elif response.status_code == 401:
                print("Token inválido ou expirado")
            elif response.status_code == 429:
                retry_after = error.get('retry_after', 60)
                print(f"Rate limit. Aguardando {retry_after}s...")
                time.sleep(retry_after)
                continue  # Retry
            elif response.status_code == 500:
                print("Erro interno do servidor")
            
            raise Exception(f"Erro API: {error.get('message', 'Erro desconhecido')}")
            
        except requests.exceptions.RequestException as e:
            print(f"Erro de conexão: {e}")
            if attempt < max_retries - 1:
                time.sleep(5)
                continue
            raise
    
    return None

async function makeApiRequest(url, data, token, maxRetries = 3) {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: { 
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${token}`
                },
                body: JSON.stringify(data)
            });

            if (response.ok) {
                return await response.json();
            }

            const error = await response.json();

            switch (response.status) {
                case 400:
                    console.error('Dados inválidos:', error.errors);
                    break;
                case 401:
                    console.error('Token inválido ou expirado');
                    break;
                case 429:
                    const retryAfter = error.retry_after || 60;
                    console.warn(`Rate limit. Aguardando ${retryAfter}s...`);
                    await new Promise(r => setTimeout(r, retryAfter * 1000));
                    continue; // Retry
                case 500:
                    console.error('Erro interno do servidor');
                    break;
            }

            throw new Error(error.message || 'Erro desconhecido');
        } catch (e) {
            console.error('Erro na requisição:', e);
            if (attempt < maxRetries - 1) {
                await new Promise(r => setTimeout(r, 5000));
                continue;
            }
            throw e;
        }
    }
}