Automatización Web Avanzada: Integra n8n con Browserless y Playwright

¿Quieres que n8n sea capaz de automatizar webs modernas, hacer scraping avanzado, generar capturas o PDFs y superar bloqueos anti-bots? La combinación de n8n con Browserless y Playwright es la solución profesional para tareas web complejas. Aquí tienes la guía definitiva, con ejemplos y archivos Docker listos para copiar y pegar.

¿Qué vas a aprender?

• Qué es Browserless y cómo usarlo con Playwright
• Cómo montar Browserless en Docker en tu propio servidor
• Cómo usar la API comercial de Browserless
• Cómo integrar todo con n8n usando el nodo HTTP Request
• Ejemplos prácticos: scraping, capturas, PDFs y automatización de sesiones
• Casos de uso reales y troubleshooting
• Consejos de seguridad y optimización

1. ¿Qué es Browserless y por qué usarlo con n8n?

Browserless es un servicio que expone navegadores Chrome/Chromium a través de una API REST, permitiendo automatizar webs modernas sin necesidad de instalar navegadores localmente. Es la solución perfecta cuando:

• Las webs cargan contenido dinámicamente con JavaScript (React, Vue, Angular)
• Necesitas superar anti-bot protection (Cloudflare, Akamai, etc.)
• Quieres generar PDFs o capturas de páginas completas
• Necesitas automatizar flujos complejos (logins, formularios multi-paso)

Playwright es la librería de automatización web de Microsoft, más moderna y potente que Puppeteer o Selenium. Soporta Chrome, Firefox y WebKit.

n8n orquesta todo el flujo: lanza tareas en Browserless, procesa resultados, guarda en bases de datos y envía alertas.

Comparativa: Browserless vs Alternativas

2. Opción A: Montar Browserless en Docker (Autoalojado)

Si quieres privacidad, control total y evitar límites de ejecuciones, monta Browserless en tu propio servidor.

Requisitos del servidor:

• RAM: Mínimo 2GB (recomendado 4GB para múltiples sesiones)
• CPU: 2 cores (cada sesión usa ~500MB RAM + 1 core)
• Disco: 2GB para imagen Docker
• OS: Linux x86_64 (Ubuntu/Debian recomendado)

Archivo docker-compose.yml completo:

version: '3.8'

services:
  browserless:
    image: browserless/chrome:latest
    container_name: browserless
    ports:
      - "3000:3000"
    environment:
      # Límite de sesiones concurrentes
      - MAX_CONCURRENT_SESSIONS=5

      # Token de autenticación (CAMBIA ESTO)
      - TOKEN=TU_TOKEN_SEGURO_AQUI_32_CARACTERES

      # Habilitar CORS (útil para testing)
      - ENABLE_CORS=true

      # Timeout por sesión (30 segundos)
      - CONNECTION_TIMEOUT=30000

      # Máximo tiempo de ejecución por sesión (5 minutos)
      - MAX_PAYLOAD_SIZE=50000000

      # Modo debug (desactivar en producción)
      - DEBUG=browserless:*

    restart: unless-stopped

    # Límites de recursos
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
        reservations:
          memory: 1G

    # Health check
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/"]
      interval: 30s
      timeout: 10s
      retries: 3

Instalación paso a paso:

# 1. Crear directorio
mkdir -p ~/browserless && cd ~/browserless

# 2. Crear docker-compose.yml (copiar contenido de arriba)
nano docker-compose.yml

# 3. Generar token seguro
echo "Token sugerido: $(openssl rand -hex 16)"

# 4. Editar TOKEN en docker-compose.yml

# 5. Levantar servicio
docker compose up -d

# 6. Ver logs
docker compose logs -f

# 7. Probar health
curl http://localhost:3000/

# Debería responder: {"status":"ok"}

Actualizar a última versión:

cd ~/browserless
docker compose pull
docker compose up -d

3. Opción B: Usar la API comercial de Browserless

Si prefieres no gestionar infraestructura o necesitas escalabilidad inmediata:

• Regístrate en Browserless.io
• Plan gratuito: 6 horas/mes de uso
• Planes de pago: desde $49/mes (250 horas)

Endpoints disponibles:

4. Integra Browserless y Playwright en n8n

Todo se hace con el nodo HTTP Request de n8n. Configuración base:

• Method: POST
• URL: http://browserless:3000/[endpoint]?token=TU_TOKEN (si self-hosted)
• Headers: Content-Type: application/json
• Body: JSON con parámetros

Ejemplo 1: Captura de pantalla de una web

Método: POST
URL: http://browserless:3000/screenshot?token=TU_TOKEN

Headers:
  Content-Type: application/json

Body (JSON):
{
  "url": "https://ejemplo.com",
  "options": {
    "fullPage": true,
    "type": "jpeg",
    "quality": 90,
    "viewport": {
      "width": 1920,
      "height": 1080
    },
    "waitUntil": "networkidle2"
  }
}

// Respuesta: imagen en base64 o binario
// En n8n: guardar con "Write Binary File"

Ejemplo 2: Generar PDF de una web

Método: POST
URL: http://browserless:3000/pdf?token=TU_TOKEN

Headers:
  Content-Type: application/json

Body (JSON):
{
  "url": "https://informe.com",
  "options": {
    "format": "A4",
    "printBackground": true,
    "displayHeaderFooter": true,
    "headerTemplate": "
Reporte generado el {{ date }}
",
    "footerTemplate": "
Página  de 
",
    "margin": {
      "top": "80px",
      "bottom": "50px",
      "left": "20px",
      "right": "20px"
    },
    "waitUntil": "networkidle2"
  }
}

Ejemplo 3: Scraping con JavaScript rendering

Método: POST
URL: http://browserless:3000/content?token=TU_TOKEN

Headers:
  Content-Type: application/json

Body (JSON):
{
  "url": "https://spa-app.com/datos",
  "waitFor": "selector",
  "selector": ".productos-lista",
  "timeout": 10000
}

// Respuesta: HTML renderizado tras ejecutar JavaScript
// Procesar con cheerio o regex en n8n

Ejemplo 4: Ejecutar script Playwright personalizado

Método: POST
URL: http://browserless:3000/function?token=TU_TOKEN

Headers:
  Content-Type: application/json

Body (JSON):
{
  "code": "export default async ({ page }) => { await page.goto('https://ejemplo.com'); await page.waitForSelector('.precio'); const precios = await page.$$eval('.precio', elements => elements.map(el => el.textContent)); return { precios }; }",
  "context": {
    "timeout": 30000
  }
}

// Respuesta: objeto JSON con data extraída

5. Casos de Uso Reales con Código Completo

Caso 1: Monitorización de precios en ecommerce

Problema: Quieres monitorizar precios en Amazon/Aliexpress que usan JavaScript dinámico.

Solución n8n workflow:

1. Schedule Trigger (cada 6 horas)
   ↓
2. HTTP Request a Browserless /function
   {
     "code": "export default async ({ page }) => {
       await page.goto('https://amazon.es/dp/PRODUCTO');
       await page.waitForSelector('#priceblock_ourprice');
       const precio = await page.$eval('#priceblock_ourprice', el => el.textContent);
       return { precio, fecha: new Date().toISOString() };
     }"
   }
   ↓
3. If (precio < 50€)
   ↓
4. Telegram node (enviar alerta)
   ↓
5. Google Sheets (guardar histórico)

Caso 2: Automatizar login + descarga de facturas

// Script Playwright para login y descarga
export default async ({ page }) => {
  // 1. Login
  await page.goto('https://proveedor.com/login');
  await page.fill('#username', 'usuario@email.com');
  await page.fill('#password', 'password123');
  await page.click('button[type="submit"]');
  await page.waitForNavigation();

  // 2. Navegar a facturas
  await page.goto('https://proveedor.com/facturas');
  await page.waitForSelector('.factura-lista');

  // 3. Descargar última factura
  const [download] = await Promise.all([
    page.waitForEvent('download'),
    page.click('.factura:first-child .btn-download')
  ]);

  const buffer = await download.createReadStream();
  return { success: true, filename: download.suggestedFilename() };
}

Caso 3: Testing automatizado de tu web

export default async ({ page }) => {
  const results = {
    tests: [],
    passed: 0,
    failed: 0
  };

  // Test 1: Homepage carga
  await page.goto('https://miweb.com');
  const title = await page.title();
  results.tests.push({
    name: 'Homepage title',
    passed: title.includes('Mi Web'),
    expected: 'Mi Web',
    actual: title
  });

  // Test 2: Formulario contacto funciona
  await page.fill('#nombre', 'Test User');
  await page.fill('#email', 'test@test.com');
  await page.fill('#mensaje', 'Mensaje de prueba');
  await page.click('button[type="submit"]');

  const confirmation = await page.waitForSelector('.mensaje-exito', { timeout: 5000 });
  results.tests.push({
    name: 'Form submission',
    passed: !!confirmation,
    expected: 'Mensaje enviado',
    actual: await confirmation.textContent()
  });

  results.passed = results.tests.filter(t => t.passed).length;
  results.failed = results.tests.filter(t => !t.passed).length;

  return results;
}

6. Troubleshooting: Problemas Comunes

Error: "Navigation timeout of 30000ms exceeded"

Causa: La página tarda más de 30s en cargar.

Soluciones:

• Aumentar timeout: "timeout": 60000 (60 segundos)
• Usar waitUntil: "domcontentloaded" en vez de "networkidle2"
• Precargar recursos: await page.setRequestInterception(true) y bloquear imágenes/fonts

Error: "Session closed. Most likely the page has been closed"

Causa: El navegador cerró antes de terminar el script.

Soluciones:

• Aumentar MAX_CONCURRENT_SESSIONS en Browserless
• Añadir delays: await page.waitForTimeout(1000)
• Verificar memoria del servidor (Docker stats)

Error 403: "Access denied" o Cloudflare Challenge

Causa: Anti-bot detection.

Soluciones:

// 1. User-Agent real
await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');

// 2. Viewport común
await page.setViewport({ width: 1920, height: 1080 });

// 3. Ejecutar stealth plugin
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', { get: () => false });
  Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
});

// 4. Delays aleatorios
await page.waitForTimeout(Math.random() * 2000 + 1000);

// 5. Movimientos de ratón
await page.mouse.move(100, 100);
await page.mouse.move(200, 200);

Browserless consume mucha RAM

Optimizaciones:

• Reducir MAX_CONCURRENT_SESSIONS a 2-3
• Añadir límites Docker: memory: 2G
• Limpiar caché periódicamente: reiniciar contenedor cada 24h
• Deshabilitar imágenes si no son necesarias

7. Performance y Escalabilidad

Tabla de rendimiento (servidor 2 cores / 4GB RAM):

Escalar horizontalmente:

Para más de 100 ejecuciones/hora concurrentes, considera:

• Opción 1: Múltiples instancias Browserless con load balancer (Nginx)
• Opción 2: Browserless Cloud (escala automática)
• Opción 3: Kubernetes + Browserless chart

8. Seguridad y Mejores Prácticas

Checklist de seguridad:

• ✅ Token fuerte: Mínimo 32 caracteres aleatorios
• ✅ Firewall: Exponer puerto 3000 solo a n8n (red interna Docker)
• ✅ HTTPS: Si expones públicamente, usar Nginx reverse proxy con SSL
• ✅ Rate limiting: Limitar peticiones por IP en Nginx
• ✅ Logs: Monitorizar uso anómalo
• ✅ Actualizaciones: Actualizar imagen semanalmente
• ✅ Sandboxing: Ejecutar Docker en usuario no-root
• ✅ Backups: Guardar scripts Playwright en Git

Variables de entorno críticas:

# Producción recomendada
TOKEN=tu_token_secreto_32_chars_minimo
MAX_CONCURRENT_SESSIONS=3
CONNECTION_TIMEOUT=60000
MAX_PAYLOAD_SIZE=10000000
ENABLE_CORS=false
DEBUG=''  # Desactivar en producción
PREBOOT_CHROME=true  # Pre-cargar Chrome para latencia menor

9. Recursos útiles

• Guía oficial Docker de Browserless
• API Reference completa de Browserless
• Documentación oficial de Playwright
• Nodo HTTP Request en n8n
• Browserless en GitHub

🔗 Recursos Adicionales sobre Automatización Web

Si quieres profundizar más en automatización web con n8n:

• n8n 2025: Automatiza 100+ Tareas Sin Código (Guía Completa V2)
• Automatización con n8n: 20 Workflows Listos para Usar (2025)
• n8n webhook no responde: 5 causas y cómo solucionarlo (2025)
• Crea tu Bot de Telegram con n8n en 15 Minutos

❓ Preguntas Frecuentes sobre n8n + Browserless

¿Qué es Browserless y para qué sirve con n8n?

Browserless es un servicio headless de Chrome/Chromium que permite automatizar navegadores web sin interfaz gráfica. Con n8n, puedes usarlo para hacer scraping de sitios web, generar PDFs, tomar screenshots, y automatizar interacciones complejas con páginas que requieren JavaScript. Es especialmente útil para superar limitaciones de scraping básico.

¿Por qué usar Browserless en vez de scraping HTTP normal?

El scraping HTTP tradicional (con HTTP Request) no funciona con sitios que cargan contenido dinámicamente con JavaScript, tienen anti-bot protection, o requieren interacciones complejas. Browserless ejecuta un navegador real, renderiza JavaScript, puede hacer clicks, rellenar formularios, y simular comportamiento humano, superando estas limitaciones.

¿Browserless es gratis?

Browserless tiene versión self-hosted gratuita que puedes instalar en tu servidor con Docker. También existe Browserless Cloud (servicio de pago desde $49/mes). La versión self-hosted es ideal si tienes un servidor con al menos 2GB RAM y quieres control total sin límites de ejecuciones.

¿Qué diferencia hay entre Browserless y Playwright?

Playwright es una librería para automatizar navegadores (similar a Puppeteer o Selenium). Browserless es un servicio que ejecuta navegadores headless y expone una API. n8n puede usar Browserless para ejecutar scripts de Playwright, combinando lo mejor de ambos: la facilidad de uso de Browserless con la potencia de Playwright.

¿Cómo evito que me bloqueen al hacer scraping?

Para evitar detección: 1) Usa user-agents reales y rotativos, 2) Añade delays aleatorios entre acciones, 3) Usa proxies si es necesario, 4) Simula comportamiento humano (movimientos de ratón, scrolls), 5) Respeta robots.txt y rate limits, 6) Usa headless: false ocasionalmente para probar, 7) Rota IPs si haces scraping masivo.

¿Puedo ejecutar Browserless en Docker junto a n8n?

Sí, es la configuración recomendada. Puedes usar docker-compose para levantar n8n y Browserless en la misma red Docker. Browserless expone puerto 3000 por defecto, y desde n8n conectas a http://browserless:3000. Necesitas al menos 2GB RAM para ambos contenedores corriendo simultáneamente.

¿Qué casos de uso son ideales para n8n + Browserless?

Casos de uso principales: 1) Scraping de sitios con JavaScript (SPAs, React, Vue), 2) Monitorización de precios en ecommerce, 3) Generación automática de PDFs de páginas web, 4) Testing automatizado de aplicaciones web, 5) Captura de screenshots para reportes, 6) Automatización de formularios complejos, 7) Extracción de datos de sitios con anti-bot.

¿Es legal hacer scraping con Browserless?

El scraping está en área gris legal. Es generalmente legal si: 1) Respetas robots.txt, 2) No sobrecargas servidores, 3) Usas datos públicos para uso personal/investigación, 4) No violas términos de servicio, 5) No extraes datos personales sin consentimiento. Para uso comercial, consulta siempre con un abogado. Muchos sitios permiten scraping razonable pero prohíben uso comercial de datos.

Conclusión

Con esta guía completa, tienes todo lo necesario para integrar Browserless y Playwright con n8n de forma profesional. Desde la instalación básica hasta casos de uso avanzados, troubleshooting y optimización de performance.

Ya sea que elijas self-hosting para control total o la API comercial para escalabilidad inmediata, Browserless + n8n te permite automatizar cualquier web moderna, superar protecciones anti-bot, y llevar tus flujos de automatización al siguiente nivel.

Próximos pasos recomendados:

• Instala Browserless siguiendo la sección 2
• Prueba los ejemplos básicos (screenshot, PDF)
• Adapta uno de los casos de uso reales a tu necesidad
• Monitoriza uso y ajusta límites según carga

¿Dudas o quieres compartir tus flujos? Únete a nuestro Discord y participa en la comunidad.