Saltar a contenido

Límites de Tasa

Descripción General

La API Pontotel implementa límites de tasa para garantizar disponibilidad y rendimiento para todos los clientes.

¿Qué es el Rate Limiting?

El rate limiting es una técnica que limita el número de solicitudes que un cliente puede hacer en un período de tiempo específico.

Límites Actuales

Entorno Límite Ventana Burst
Sandbox 1000 solicitudes 1 hora 100/min
Producción 500 solicitudes 1 hora 50/min

Encabezados de Rate Limit

Cada respuesta de la API incluye encabezados informativos:

HTTP
1
2
3
X-RateLimit-Limit: 500
X-RateLimit-Remaining: 487
X-RateLimit-Reset: 1642089600
Encabezado Descripción
X-RateLimit-Limit Límite total de solicitudes
X-RateLimit-Remaining Solicitudes restantes
X-RateLimit-Reset Timestamp Unix cuando el límite se reinicia

Respuesta 429 (Too Many Requests)

Cuando el límite es excedido:

JSON
1
2
3
4
5
6
7
8
{
  "error": "rate_limit_exceeded",
  "message": "Has excedido el límite de solicitudes",
  "limit": 500,
  "remaining": 0,
  "reset_at": "2025-02-09T15:00:00Z",
  "retry_after": 3600
}

Código de Estado: 429 Too Many Requests

Encabezado adicional:

HTTP
1
Retry-After: 3600

Buenas Prácticas

1. Monitorear Encabezados

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def hacer_solicitud_con_monitoreo(url, headers):
    response = requests.get(url, headers=headers)

    # Verificar rate limit
    limit = int(response.headers.get('X-RateLimit-Limit', 0))
    remaining = int(response.headers.get('X-RateLimit-Remaining', 0))

    print(f"Rate Limit: {remaining}/{limit} solicitudes restantes")

    # Alertar cuando esté cerca del límite
    if remaining < limit * 0.1:  # Menos del 10%
        print("⚠️ ATENCIÓN: ¡Cerca del límite de tasa!")

    return response
JavaScript
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
async function hacerSolicitudConMonitoreo(url, headers) {
  const response = await fetch(url, { headers });

  const limit = parseInt(response.headers.get('X-RateLimit-Limit') || '0');
  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');

  console.log(`Rate Limit: ${remaining}/${limit} solicitudes restantes`);

  if (remaining < limit * 0.1) {
    console.warn('⚠️ ATENCIÓN: ¡Cerca del límite de tasa!');
  }

  return response;
}

2. Implementar Reintento con Backoff

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import time
from datetime import datetime

def solicitud_con_reintento(url, headers, max_reintentos=3):
    for intento in range(max_reintentos):
        response = requests.get(url, headers=headers)

        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 60))
            reset_time = datetime.fromtimestamp(
                int(response.headers.get('X-RateLimit-Reset', 0))
            )

            print(f"⏳ Límite de tasa alcanzado. Esperando {retry_after}s...")
            print(f"   Reinicio esperado: {reset_time}")

            time.sleep(retry_after)
            continue

        return response

    raise Exception("Máximo de reintentos excedido")

3. Caché de Respuestas

Reduce solicitudes almacenando respuestas en caché:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
from datetime import datetime, timedelta

class PontotelClient:
    def __init__(self):
        self.cache = {}
        self.cache_duration = timedelta(minutes=5)

    def get_con_cache(self, url, headers):
        # Verificar caché
        if url in self.cache:
            cached_data, cached_time = self.cache[url]
            if datetime.now() - cached_time < self.cache_duration:
                print("✅ Retornando del caché")
                return cached_data

        # Hacer solicitud
        response = requests.get(url, headers=headers)

        # Almacenar en caché
        self.cache[url] = (response.json(), datetime.now())

        return response.json()

4. Solicitudes en Lote

Agrupa múltiples operaciones cuando sea posible:

Python
1
2
3
4
5
6
# ❌ NO HACER: Múltiples solicitudes individuales
for user_id in user_ids:
    get_user(user_id)  # ¡100 solicitudes!

# ✅ HACER: Una solicitud con filtros
get_users(ids=",".join(user_ids))  # 1 solicitud

5. Paginación Eficiente

Usa paginación para evitar solicitudes innecesarias:

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def listar_todos_usuarios(base_url, headers):
    all_users = []
    url = f"{base_url}/usuarios/"

    while url:
        response = requests.get(url, headers=headers)
        data = response.json()

        all_users.extend(data['results'])
        url = data['next']  # Siguiente página o None

        print(f"Procesados: {len(all_users)}/{data['count']}")

    return all_users

Aumentar Límites

Si necesitas límites mayores:

  1. Contacta al soporte comercial
  2. Presenta tu caso de uso
  3. Considera actualizar tu plan

Planes Enterprise

Los planes enterprise ofrecen:

  • Límites de tasa personalizados
  • Mayor burst
  • SLA garantizado
  • Soporte prioritario

Monitoreo

Dashboard Recomendado

Monitorea métricas importantes:

  • Solicitudes por hora
  • Tasa de error 429
  • Tiempo promedio de respuesta
  • Porcentaje de uso del límite de tasa

Alertas

Configura alertas para:

  • 80% del límite de tasa alcanzado
  • Errores 429 consecutivos
  • Tiempo de respuesta > 2s

Próximos Pasos