¿Qué debes validar siempre al consumir una API externa?

Sin validar estado HTTP y forma del payload, los fallos se propagan y aparecen errores difíciles de diagnosticar.

Requests, APIs y JSON en Python: integración robusta con servicios externos

Aprende a consumir APIs REST con control de errores HTTP, timeouts y parseo JSON defensivo para flujos de backend confiables.

¿Cuánto sabes de Python?

📘 Teoría

1) Llamadas HTTP con `requests` y timeout

Nunca llames una API sin timeout: podrías bloquear proceso indefinidamente.

`requests.get(url, timeout=5)` evita bloqueos eternos cuando el servicio externo se degrada.

`response.status_code` y `response.raise_for_status()` son controles básicos para detectar respuestas no exitosas.

No mezcles validación HTTP con lógica de negocio; encapsula cliente en funciones dedicadas.

GET con validación de estado

import requests


def obtener_usuario(user_id: int) -> dict:
    url = f'https://api.ejemplo.com/users/{user_id}'
    response = requests.get(url, timeout=5)
    response.raise_for_status()
    return response.json()

2) Parseo JSON defensivo

Que llegue JSON no significa que tenga la estructura esperada.

Valida claves obligatorias antes de usar datos (`id`, `status`, `data`, etc.).

`dict.get(...)` con fallback ayuda, pero en campos críticos conviene fallar explícitamente con mensaje claro.

Si el contrato de API cambia, una validación temprana evita errores silenciosos en capas superiores.

Extracción segura con `get`

Fallback para campos opcionales.

Validación de campos obligatorios

Fallar rápido cuando contrato no se cumple.

3) Manejo de errores de red y API

Distingue fallos de red, timeout y errores HTTP para responder correctamente.

`requests.exceptions.Timeout` indica latencia excesiva; `ConnectionError` apunta a fallo de conectividad.

`HTTPError` significa que el servidor respondió, pero con estado no 2xx.

Registrar contexto (endpoint, método, request_id) acelera diagnóstico en producción.

Usa timeout explícito en todas las llamadas.
Valida `status_code` y estructura JSON.
Separa cliente HTTP de reglas de negocio.
Registra contexto útil para soporte.

Manejo específico de errores

import requests


def obtener_json(url: str) -> dict:
    try:
        r = requests.get(url, timeout=5)
        r.raise_for_status()
        return r.json()
    except requests.exceptions.Timeout:
        raise RuntimeError('Timeout al consultar API')
    except requests.exceptions.ConnectionError:
        raise RuntimeError('Error de conexión con API')
    except requests.exceptions.HTTPError as e:
        raise RuntimeError(f'Error HTTP: {e.response.status_code}')

1 1) Llamadas HTTP con `requests` y timeout 2 2) Parseo JSON defensivo 3 3) Manejo de errores de red y API