Domina el Nodo HTTP Request en n8n y Automatiza tu Flujo

El nodo HTTP Request es EL superpoder de n8n. Con él puedes conectar literalmente cualquier API del mundo, desde servicios gigantes como AWS hasta tu propia API casera. Si dominas HTTP Request, desbloqueas el 100% del potencial de n8n, porque la mayoría de servicios modernos exponen APIs REST/GraphQL que puedes consumir con este nodo.

En esta guía completa aprenderás TODO sobre el nodo HTTP Request: desde requests básicos hasta técnicas avanzadas de autenticación, manejo de errores, paginación, rate limiting y debugging. Con ejemplos reales que puedes copiar directamente en tus workflows.

¿Por qué el nodo HTTP Request es tan poderoso?

n8n tiene 400+ integraciones nativas (Slack, Gmail, Notion, etc), pero ¿qué pasa si necesitas conectar con un servicio sin integración nativa? HTTP Request al rescate.

Ventajas del nodo HTTP Request:

• ✅ Universal: Conecta con CUALQUIER API REST/GraphQL/SOAP
• ✅ Sin esperar integraciones: No dependes de que n8n añada soporte oficial
• ✅ Control total: Headers, auth, body, params personalizados
• ✅ Importación desde cURL: Copia comando curl y conviértelo en nodo
• ✅ Variables dinámicas: Usa datos de nodos anteriores
• ✅ Error handling: Reintentos automáticos, fallbacks, logging
• ✅ Testing integrado: Prueba requests antes de activar workflow

Casos de uso reales:

• Conectar con API interna de tu empresa
• Consultar bases de datos vía API (Supabase, Firebase)
• Scraping web (con Puppeteer + HTTP Request)
• Integrar servicios SaaS sin integración nativa
• Crear webhooks para recibir/enviar datos
• Orquestar microservicios

Anatomía del nodo HTTP Request

Antes de empezar a construir, entiende las partes de un HTTP request:

HTTP Request = Método + URL + Headers + Body (opcional) + Auth (opcional)

Métodos HTTP: Cuándo usar cada uno

GET – Leer datos

Cuándo usar: Obtener información sin modificar nada en el servidor.

Ejemplo: Obtener lista de usuarios

• Method: GET
• URL: https://jsonplaceholder.typicode.com/users
• Query Parameters:
  • _limit: 5
  • _page: 1

Respuesta esperada:

[
  {
    "id": 1,
    "name": "Leanne Graham",
    "email": "leanne@example.com"
  },
  ...
]

POST – Crear nuevo recurso

Cuándo usar: Crear algo nuevo en el servidor (usuario, post, orden).

Ejemplo: Crear nuevo usuario

• Method: POST
• URL: https://jsonplaceholder.typicode.com/users
• Body Type: JSON
• Body:

  {
    "name": "Juan Pérez",
    "email": "juan@ejemplo.com",
    "phone": "+34 600 123 456"
  }
  

PUT – Reemplazar recurso completo

Cuándo usar: Actualizar TODO el recurso (reemplaza completamente).

Ejemplo: Actualizar usuario completo

• Method: PUT
• URL: https://jsonplaceholder.typicode.com/users/1
• Body:

  {
    "id": 1,
    "name": "Juan Pérez Modificado",
    "email": "nuevo@email.com",
    "phone": "+34 600 999 999"
  }
  

PATCH – Actualizar parcialmente

Cuándo usar: Modificar solo algunos campos (más eficiente que PUT).

Ejemplo: Cambiar solo el email

• Method: PATCH
• URL: https://jsonplaceholder.typicode.com/users/1
• Body:

  {
    "email": "nuevo_email@ejemplo.com"
  }
  

DELETE – Eliminar recurso

Cuándo usar: Borrar algo del servidor.

Ejemplo: Eliminar usuario

• Method: DELETE
• URL: https://jsonplaceholder.typicode.com/users/1

Respuesta esperada: Status 204 No Content (éxito) o 200 OK con confirmación JSON.

Autenticación: Todas las formas de autenticarte

1. API Key en Header

La más común y simple. Añades un header con tu clave:

• Header Name: X-API-Key (o el nombre específico de la API)
• Header Value: tu_api_key_aqui

Ejemplo real: OpenWeather API

GET https://api.openweathermap.org/data/2.5/weather?q=Madrid
Header: X-API-Key: 1234567890abcdef

2. API Key en Query Parameter

Algunas APIs quieren la key en la URL:

• URL: https://api.ejemplo.com/data?apikey=TU_KEY

3. Basic Authentication

Usuario + contraseña codificados en Base64:

• En n8n: Authentication → Basic Auth
• User: tu_usuario
• Password: tu_password

n8n automáticamente genera el header: Authorization: Basic dXNlcjpwYXNz...

4. Bearer Token (JWT)

Muy común en APIs modernas (OAuth2, JWT):

• En n8n: Authentication → Header Auth
• Name: Authorization
• Value: Bearer tu_token_aqui

Ejemplo: API de GitHub

GET https://api.github.com/user
Header: Authorization: Bearer ghp_1234567890abcdef...

5. OAuth2 (flujo completo)

Para APIs que requieren OAuth2 (Google, Microsoft, etc):

1. En n8n: Authentication → OAuth2
2. Configura:
   • Authorization URL: URL de autorización del proveedor
   • Access Token URL: URL para obtener token
   • Client ID: De tu app OAuth
   • Client Secret: De tu app OAuth
   • Scope: Permisos que solicitas
3. n8n te redirige al flujo de autorización
4. Autoriza y n8n guarda el token automáticamente

6. Autenticación personalizada (Custom)

Para APIs con métodos únicos de auth:

// Ejemplo: API que requiere firma HMAC
const crypto = require('crypto');

const timestamp = Date.now();
const message = `${timestamp}${$json.method}${$json.path}`;
const signature = crypto.createHmac('sha256', 'SECRET_KEY')
                       .update(message)
                       .digest('hex');

// Añadir headers
$json.headers = {
  'X-Timestamp': timestamp,
  'X-Signature': signature
};

return $json;

Importar desde cURL: El atajo definitivo

Si tienes un comando cURL funcionando (de Postman, documentación API, etc), puedes convertirlo directamente en nodo HTTP Request:

Paso a paso

1. Copia tu comando cURL completo:

   curl -X POST https://api.ejemplo.com/users \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer token123" \
     -d '{"name":"Juan","email":"juan@test.com"}'
   

2. En n8n, añade nodo HTTP Request
3. Haz clic en Import from cURL (icono arriba a la derecha)
4. Pega el comando cURL completo
5. ¡Listo! n8n extrae automáticamente:
   • Método (POST)
   • URL (https://api.ejemplo.com/users)
   • Headers (Content-Type, Authorization)
   • Body (JSON con name y email)

Nota: Esta función ahorra HORAS de configuración manual. Úsala siempre que tengas un cURL de ejemplo.

Variables dinámicas: Hacer requests inteligentes

El verdadero poder del nodo HTTP Request aparece cuando usas datos de nodos anteriores:

Ejemplo 1: Buscar usuario por ID dinámico

Workflow: Webhook recibe ID → HTTP Request obtiene usuario

• URL: https://api.ejemplo.com/users/{{ $json.userId }}

Si el webhook recibe {"userId": 42}, la URL resultante será: https://api.ejemplo.com/users/42

Ejemplo 2: POST con datos dinámicos

Body JSON:

{
  "name": "{{ $json.name }}",
  "email": "{{ $json.email }}",
  "timestamp": "{{ $now.toISO() }}",
  "source": "n8n-automation"
}

n8n reemplaza las expresiones {{ }} con valores reales antes de enviar el request.

Ejemplo 3: Headers dinámicos con credenciales

Usar credenciales guardadas en variables de entorno:

• Header Name: Authorization
• Header Value: Bearer {{ $env.API_TOKEN }}

Manejo de respuestas: Procesar datos

Extraer campos específicos

Si la API devuelve JSON complejo, extrae solo lo que necesitas con expresiones:

// API responde:
{
  "data": {
    "users": [
      {"id": 1, "name": "Juan"},
      {"id": 2, "name": "Ana"}
    ]
  },
  "meta": {"total": 2}
}

// Extraer solo los nombres:
{{ $json.data.users.map(u => u.name) }}
// Resultado: ["Juan", "Ana"]

Iterar sobre arrays de respuestas

Si la API devuelve array de items, usa Split In Batches para procesarlos uno a uno:

1. HTTP Request obtiene lista de usuarios
2. Nodo Split In Batches con batch size = 1
3. Procesa cada usuario individualmente
4. Loop hasta terminar todos

Paginación: Obtener todos los datos

Muchas APIs limitan resultados a 100 items por request. Para obtener TODO, necesitas paginar:

Método 1: Paginación por offset/limit

// Workflow con loop

1. Set initial variables:
   - offset: 0
   - limit: 100
   - hasMore: true

2. LOOP START (while hasMore === true):

   3. HTTP Request:
      URL: https://api.ejemplo.com/users?offset={{ $json.offset }}&limit={{ $json.limit }}

   4. Code: Check if more results
      const results = $input.all();
      const hasMore = results.length === $json.limit;
      const newOffset = $json.offset + $json.limit;

      return { hasMore, offset: newOffset };

   5. IF hasMore === false → STOP LOOP

6. Merge all results

Método 2: Paginación por cursor (más eficiente)

// Algunas APIs usan cursor-based pagination

1. HTTP Request con cursor inicial
   URL: https://api.ejemplo.com/users?cursor=initial

2. Response contiene: {data: [...], next_cursor: "abc123"}

3. Code: Extract next cursor
   return { nextCursor: $json.next_cursor };

4. Loop hasta que next_cursor === null

Rate Limiting: No saturar APIs

Las APIs tienen límites de requests por segundo/minuto. Si los excedes, te bloquean (HTTP 429).

Estrategia 1: Delays entre requests

Añade nodo Wait después de HTTP Request:

• Wait Time: 1000 ms (1 segundo)
• Resultado: Máximo 60 requests/minuto

Estrategia 2: Exponential backoff con retry

Si recibes 429, espera cada vez más tiempo antes de reintentar:

// En nodo HTTP Request → Options → Response → Error

IF error.statusCode === 429:
  - Wait: 2^retry_count seconds
  - Retry request
  - Increment retry_count

En n8n, configura reintentos automáticos:

• Options → Request → Max Retries: 3
• Retry On: Status Code → 429
• Wait Between Retries: 1000 ms

Error Handling: Qué hacer cuando falla

HTTP Status Codes que debes conocer

Configurar error handling en n8n

En el nodo HTTP Request:

1. Options → Response
2. Ignore Response Code: ❌ (NO activar, queremos manejar errores)
3. Continue On Fail: ✅ ACTIVAR (workflow sigue aunque falle)
4. Conecta un nodo IF después para detectar errores:
   • Condition: {{ $json.error !== undefined }}
   • True → Manejar error (enviar notificación, log, etc)
   • False → Continuar normal

Debugging: Cómo encontrar problemas

1. Inspeccionar request completo

En n8n, haz clic en el nodo HTTP Request ejecutado y ve a pestaña JSON. Verás:

• Input: Qué recibió el nodo
• Output: Qué devolvió la API
• Headers enviados
• Status code

2. Usar RequestBin para inspeccionar requests

Si no estás seguro qué está enviando n8n:

1. Ve a requestbin.com y crea un bin temporal
2. Copia la URL generada (ej: https://requestbin.com/r/abcd1234)
3. En n8n, cambia temporalmente la URL del HTTP Request a tu RequestBin
4. Ejecuta el workflow
5. Ve a RequestBin y verás EXACTAMENTE qué envió n8n (headers, body, método)

3. Comparar con cURL funcionando

Si un cURL funciona pero el nodo n8n falla:

# Ejecuta cURL con verbose para ver todo
curl -v -X POST https://api.ejemplo.com/users \
  -H "Content-Type: application/json" \
  -d '{"name":"test"}'

# Compara headers enviados con los de n8n

Diferencias comunes:

• cURL añade User-Agent: curl/7.x automáticamente
• n8n añade headers adicionales que algunas APIs rechazan
• Formato de fechas (ISO vs Unix timestamp)

Performance: Optimizar requests

1. Requests en paralelo con Split In Batches

Si necesitas hacer 100 requests, hazlos en paralelo (máximo 5 simultáneos para no saturar):

1. Nodo con array de 100 items
2. Split In Batches: Batch Size = 5
3. HTTP Request (se ejecuta 5 a la vez)
4. Loop hasta completar todos

Resultado: 100 requests en ~20 iteraciones (5 por iteración) vs 100 secuenciales.

2. Caché de respuestas con Redis

Para APIs con datos que cambian poco, cachea las respuestas:

// Antes del HTTP Request

1. Redis GET: Buscar en cache
   Key: api_cache_{{ $json.endpoint }}

2. IF cache hit → Retornar dato cacheado (ahorro de API call)

3. IF cache miss:
   - HTTP Request
   - Redis SET: Guardar respuesta con TTL 3600s (1h)

3. Comprimir respuestas grandes

Si la API soporta compresión, actívala:

• Header: Accept-Encoding: gzip, deflate

Reduce ancho de banda y tiempo de respuesta significativamente.

Casos de uso avanzados

Caso 1: Webhook receiver + respuesta procesada

Escenario: Recibir webhook de Stripe, consultar datos adicionales, procesar y responder.

1. Webhook Trigger (recibe evento de Stripe)

2. HTTP Request a Stripe API:
   GET https://api.stripe.com/v1/customers/{{ $json.customer_id }}
   Header: Authorization: Bearer sk_test_...

3. Code: Procesar datos
   const customer = $input.first().json;
   const eventType = $('Webhook').item.json.type;

   return {
     customerName: customer.name,
     email: customer.email,
     eventType: eventType
   };

4. HTTP Request: Enviar a tu backend
   POST https://tubackend.com/process-stripe-event
   Body: {{ $json }}

5. Respond to Webhook: Confirmar a Stripe
   Status: 200
   Body: {"received": true}

Caso 2: GraphQL Query

n8n soporta GraphQL con HTTP Request:

• Method: POST
• URL: https://api.github.com/graphql
• Headers:
  • Authorization: Bearer tu_github_token
  • Content-Type: application/json
• Body:

  {
    "query": "{ viewer { login repositories(first: 5) { nodes { name } } } }"
  }
  

Caso 3: File upload (multipart/form-data)

Para subir archivos:

• Method: POST
• Body Type: Multipart-Form-Data
• Add Field:
  • Name: file
  • Input Data Field Name: data (del nodo anterior que leyó el archivo)

Recursos y ejemplos listos para usar

Workflows de ejemplo

• Paginación automática con HTTP Request
• GraphQL queries en n8n
• File upload con multipart/form-data

APIs públicas para practicar

• JSONPlaceholder: https://jsonplaceholder.typicode.com (fake REST API, perfecta para aprender)
• ReqRes: https://reqres.in/api (API de prueba con usuarios ficticios)
• GitHub API: https://api.github.com (real, requiere token)
• OpenWeather: https://openweathermap.org/api (datos del clima, gratis con registro)

Artículos relacionados

• Guía Completa de n8n v2: De Cero a Experto
• Crea un Chatbot Sencillo con n8n
• Webhooks Seguros en n8n con Autenticación
• Guía Completa de Nodos en n8n
• 20 Workflows de n8n Listos para Usar

Preguntas Frecuentes (FAQ)

¿Puedo usar HTTP Request para SOAP APIs?

Sí, pero es más complicado. SOAP usa XML en lugar de JSON. Necesitas:

1. Method: POST
2. Header: Content-Type: text/xml
3. Body: XML con SOAP envelope (usa plantillas)

Para SOAP complejo, considera usar un nodo custom o middleware que convierta SOAP a REST.

¿Cómo sé si mi API key es válida?

Haz un request simple (GET a un endpoint público) con la key. Si obtienes:

• 200 OK → Key válida
• 401 Unauthorized → Key inválida o expirada
• 403 Forbidden → Key válida pero sin permisos para ese endpoint

¿Por qué mi request funciona en Postman pero no en n8n?

Causas comunes:

• Headers automáticos: Postman añade algunos headers que n8n no. Cópialos manualmente.
• Variables de entorno: Postman usa variables que n8n no conoce. Reemplaza con valores reales.
• JSON escaping: n8n puede escapar caracteres especiales diferente. Usa comillas simples o expresiones.
• SSL/TLS: Algunas APIs con certificados auto-firmados fallan en n8n. Desactiva verificación SSL (solo para desarrollo).

¿Puedo hacer requests a APIs internas de mi red?

Sí, si n8n está en la misma red o tiene acceso. Usa URLs privadas (192.168.x.x, 10.x.x.x) directamente. Si n8n está en cloud, necesitas exponer tu API con túnel (Cloudflare Tunnel, ngrok) o VPN.

¿Cómo manejo APIs que requieren múltiples pasos de autenticación?

Ejemplo: API que primero necesita login para obtener token, luego ese token en requests subsecuentes:

1. HTTP Request → POST a /auth/login con user/pass
2. Extrae token de respuesta: {{ $json.access_token }}
3. Guarda en variable global o credential
4. Requests posteriores usan ese token en header Authorization

¿Puedo reintentar solo ciertos tipos de errores?

Sí, en Options → Request:

• Retry On Status Codes: 429,500,502,503,504
• NO reintentes 4xx (client errors) porque son errores de tu request, no del servidor

Conclusión y próximos pasos

Has dominado el nodo HTTP Request de n8n, desde requests básicos hasta técnicas avanzadas de autenticación, paginación, error handling y debugging. Con este conocimiento puedes integrar literalmente cualquier API existente, sin esperar a que n8n añada soporte oficial.

Checklist de maestría HTTP Request:

• ✅ Conozco los 5 métodos HTTP y cuándo usar cada uno
• ✅ Sé configurar 6 tipos de autenticación diferentes
• ✅ Puedo importar desde cURL en segundos
• ✅ Uso variables dinámicas para requests inteligentes
• ✅ Manejo paginación automática para obtener todos los datos
• ✅ Implemento rate limiting y exponential backoff
• ✅ Configuro error handling robusto
• ✅ Sé debuggear requests con RequestBin y verbose logs
• ✅ Optimizo performance con paralelización y caché

Próximos pasos recomendados:

1. Conecta una API real de tu stack (CRM, ERP, base de datos)
2. Construye un workflow de sincronización bidireccional entre dos servicios
3. Implementa webhook receiver + processor completo
4. Experimenta con GraphQL para APIs modernas
5. Añade monitoring/alerting cuando requests fallen

¿Quieres más automatización con n8n?

• 20 Workflows Listos para Copiar
• Automatización Web con n8n + Playwright
• n8n + LangChain: Pipelines de IA

¿Te ha resultado útil esta guía? Con el nodo HTTP Request dominado, no hay API que se te resista. ¡Ahora sal y automatiza todo lo que encuentres!