X-RateLimit-Limit: 100
X-RateLimit-Remaining: 85
X-RateLimit-Reset: 1674820800000
X-RateLimit-Window: 60
X-RateLimit-Policy: user

curl -I https://api.tarefaai.com/api/tasks \
  -H "Authorization: Bearer {token}"

HTTP/1.1 200 OK
Content-Type: application/json
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 85
X-RateLimit-Reset: 1674820800000
X-RateLimit-Window: 60
X-RateLimit-Policy: user

{
  "success": false,
  "error": "Rate limit exceeded",
  "message": "Too many requests. Please try again in 45 seconds.",
  "details": {
    "limit": 100,
    "remaining": 0,
    "reset": 1674820800000,
    "resetIn": 45,
    "retryAfter": 45
  }
}

HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 45
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1674820800000

async function fetchWithRetry(url: string, options: RequestInit, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);
 
    if (response.status !== 429) {
      return response;
    }
 
    // Ler Retry-After do header
    const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 
    // Exponential backoff: 1s, 2s, 4s, 8s...
    const delay = Math.min(retryAfter * 1000, Math.pow(2, i) * 1000);
 
    console.log(`Rate limited. Retrying in ${delay}ms...`);
    await new Promise(resolve => setTimeout(resolve, delay));
  }
 
  throw new Error('Max retries exceeded');
}
 
// Uso
try {
  const response = await fetchWithRetry('https://api.tarefaai.com/api/tasks', {
    headers: { Authorization: `Bearer ${token}` }
  });
  const data = await response.json();
} catch (error) {
  console.error('Failed after retries:', error);
}

class TarefaAIClient {
  private remaining: number = 100;
  private resetAt: number = Date.now() + 60000;
 
  async request(endpoint: string, options: RequestInit) {
    // Aguardar reset se necessário
    if (this.remaining <= 0) {
      const waitTime = this.resetAt - Date.now();
      if (waitTime > 0) {
        console.log(`Waiting ${waitTime}ms for rate limit reset...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
      }
    }
 
    const response = await fetch(endpoint, options);
 
    // Atualizar contadores
    this.remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
    this.resetAt = parseInt(response.headers.get('X-RateLimit-Reset') || '0');
 
    if (response.status === 429) {
      const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      return this.request(endpoint, options); // Retry
    }
 
    return response;
  }
}
 
// Uso
const client = new TarefaAIClient();
const response = await client.request('https://api.tarefaai.com/api/tasks', {
  headers: { Authorization: `Bearer ${token}` }
});

class RateLimitedQueue {
  private queue: Array<() => Promise<any>> = [];
  private processing = false;
  private requestsPerMinute = 100;
  private delay = 60000 / this.requestsPerMinute; // ~600ms entre requests
 
  async enqueue<T>(fn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.queue.push(async () => {
        try {
          const result = await fn();
          resolve(result);
        } catch (error) {
          reject(error);
        }
      });
 
      this.process();
    });
  }
 
  private async process() {
    if (this.processing || this.queue.length === 0) return;
 
    this.processing = true;
 
    while (this.queue.length > 0) {
      const task = this.queue.shift()!;
      await task();
      await new Promise(resolve => setTimeout(resolve, this.delay));
    }
 
    this.processing = false;
  }
}
 
// Uso
const queue = new RateLimitedQueue();
 
for (let i = 0; i < 200; i++) {
  queue.enqueue(async () => {
    const response = await fetch('https://api.tarefaai.com/api/tasks');
    return response.json();
  });
}

curl -X GET https://api.tarefaai.com/api/usage \
  -H "Authorization: Bearer {token}"

{
  "success": true,
  "usage": {
    "period": "2025-01-17",
    "executions": {
      "used": 35,
      "limit": 50,
      "remaining": 15,
      "percentage": 70.0
    },
    "tokens": {
      "used": 45000,
      "limit": 100000,
      "remaining": 55000,
      "percentage": 45.0
    },
    "storage": {
      "usedBytes": 25000000,
      "limitBytes": 104857600,
      "usedMB": 23.8,
      "limitMB": 100,
      "percentage": 23.8
    },
    "rateLimits": {
      "hitToday": 3,
      "endpoints": [
        {
          "endpoint": "/api/agent/process",
          "hits": 2,
          "lastHit": "2025-01-17T14:30:00.000Z"
        }
      ]
    }
  }
}

curl -X POST https://api.tarefaai.com/api/usage/alerts \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" \
  -d '{
    "threshold": 80,
    "notifyEmail": true,
    "notifyWebhook": true
  }'

// ✅ BOM: Cache de dados que não mudam frequentemente
const cache = new Map<string, { data: any; expiresAt: number }>();
 
async function getTasks() {
  const cached = cache.get('tasks');
  if (cached && cached.expiresAt > Date.now()) {
    return cached.data;
  }
 
  const response = await fetch('https://api.tarefaai.com/api/tasks');
  const data = await response.json();
 
  cache.set('tasks', {
    data,
    expiresAt: Date.now() + 60000 // Cache 1 min
  });
 
  return data;
}

// ❌ RUIM: Polling constante
setInterval(async () => {
  const executions = await fetch('/api/executions');
  // Consome rate limit desnecessariamente
}, 5000);
 
// ✅ BOM: Configure webhook
// Você recebe notificação quando algo muda
app.post('/webhook', (req, res) => {
  const { event, data } = req.body;
  if (event === 'task.completed') {
    handleTaskCompleted(data);
  }
  res.status(200).send('OK');
});

// ❌ RUIM: Múltiplas requisições individuais
for (const task of tasks) {
  await fetch(`/api/tasks/${task.id}`); // 100 requests
}
 
// ✅ BOM: Uma requisição batch
const response = await fetch('/api/tasks', {
  method: 'POST',
  body: JSON.stringify({ ids: tasks.map(t => t.id) })
});

// ✅ BOM: Sempre verifique headers
const response = await fetch('https://api.tarefaai.com/api/tasks');
 
const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
const limit = parseInt(response.headers.get('X-RateLimit-Limit') || '100');
 
if (remaining < limit * 0.1) {
  console.warn(`Rate limit baixo: ${remaining}/${limit}`);
  // Reduzir velocidade de requisições
}

// ✅ BOM: Falhe graciosamente
async function fetchData() {
  try {
    const response = await fetch('https://api.tarefaai.com/api/tasks');
 
    if (response.status === 429) {
      // Usar cache antigo ou dados estáticos
      return getCachedData();
    }
 
    return await response.json();
  } catch (error) {
    // Fallback para dados locais
    return getLocalFallbackData();
  }
}

# Ver limites atuais
curl -I https://api.tarefaai.com/api/tasks \
  -H "Authorization: Bearer {token}" | grep -i ratelimit

# Fazer muitas requisições rápidas
for i in {1..150}; do
  curl https://api.tarefaai.com/api/tasks \
    -H "Authorization: Bearer {token}" &
done
wait