Blinkbox

Plataforma de automatización de código abierto (alternativa a Zapier / Make / n8n) expuesta como servidor MCP. Los agentes listan, crean, ejecutan, activan y depuran flujos de trabajo en más de 250 integraciones, scraping headless con Chromium y nodos JS en sandbox; incluye un SKILL.md con el catálogo de nodos y la sintaxis de expresiones. Alojada (plan gratuito, clave API) o autoalojada.

GitHub

Prueba este MCPPatrocinado

Servidor MCP alojado

npx add-mcp 'https://mcp.blinkbox.net/mcp'

Se instala en Claude Code, Codex, Cursor y más

Documentación

BlinkBox

Plataforma de automatización de código abierto (alternativa a Zapier / Make / n8n) con un servidor MCP nativo: conecta Claude Code, Cursor o ChatGPT y deja que el agente construya, ejecute y depure tus flujos de trabajo.

Nivel gratuito alojado en blinkbox.net (sin tarjeta) · autoalojamiento con Node 22 + MongoDB + Redis · MIT.

Qué hace

Servidor MCP: toda la plataforma está expuesta a través del Protocolo de Contexto de Modelo (HTTP Streamable). Tu agente de codificación lista, crea, ejecuta, activa y depura flujos de trabajo con llamadas a herramientas: consulta Úsalo desde Claude Code
Habilidad de agente: un SKILL.md que enseña al agente los campos de nodo, la sintaxis de expresiones y las reglas de ejecución, de modo que un flujo funcional requiere ~4 llamadas a herramientas en lugar de ~12 de prueba y error
Lienzo de arrastrar y soltar: todo lo que el agente construye es un flujo de trabajo normal que puedes abrir y editar visualmente
Agentes de IA: nodos LLM que razonan sobre datos y producen resultados estructurados
Extracción sin interfaz: grupo completo de Chromium, evita anti-bots, renderiza JavaScript
Entorno de pruebas de código: escribe JavaScript en un entorno V8 aislado con límites de memoria
Más de 250 integraciones: Gmail, Slack, Stripe, GitHub, Notion, Airtable, Shopify y más
Almacén de credenciales cifrado: AES-256-GCM; los secretos nunca salen del servidor sin cifrar

Úsalo desde Claude Code, Cursor o ChatGPT (60 segundos)

Regístrate en blinkbox.net → Panel → MCP → crea una clave de API.

Añade el servidor a tu cliente:

# Claude Code
claude mcp add --transport http blinkbox https://mcp.blinkbox.net/mcp \
  --header "Authorization: Bearer <your key>"

// Cursor / Claude Desktop / any client that takes a JSON config
{
  "mcpServers": {
    "blinkbox": {
      "url": "https://mcp.blinkbox.net/mcp",
      "headers": { "Authorization": "Bearer <your key>" }
    }
  }
}

Los clientes que no pueden enviar encabezados pueden pasar la clave en la URL en su lugar: https://mcp.blinkbox.net/mcp?key=<your key>.

(Recomendado) instala la habilidad para que el agente conozca el catálogo de nodos y la sintaxis de expresiones:

mkdir -p ~/.claude/skills/blinkbox && curl -fsSL \
  https://raw.githubusercontent.com/blinkboxhq/Blinkbox/main/.claude/skills/blinkbox/SKILL.md \
  -o ~/.claude/skills/blinkbox/SKILL.md

Pide lo que quieras:

"Cada mañana a las 8, encuentra dentistas en Berlín en OpenStreetMap que tengan sitio web, correo y teléfono, elimina duplicados contra mi hoja de Google y añade los nuevos."

El agente llama a create_automation, lo ejecuta con run_automation, lee get_execution_logs cuando algo falla y activate_automation cuando está en verde. Las aplicaciones OAuth (Google, Slack, Notion…) se conectan una vez por ti en el panel: el agente nunca ve tus tokens.

Herramientas: list_automations · get_automation · create_automation · run_automation · activate_automation · deactivate_automation · rename_automation · delete_automation · list_executions · get_execution · get_execution_logs · list_nodes · get_node · list_node_actions · list_credentials · create_credential · blinkbox_api_get · blinkbox_api

¿Autoalojamiento? El mismo servidor está en <your backend>/api/mcp: crea claves en tu propio panel.

Pila tecnológica

Capa	Tecnología
Frontend	React 18 + Vite + Tailwind CSS + ReactFlow
Backend	Node.js + Express + MongoDB Atlas + Redis
IA	Anthropic Claude (principal) → Groq → Gemini (respaldo)
Extracción	Puppeteer + Chromium
Ejecución	Motor distribuido basado en cursores, 4 celdas de trabajo
Despliegue	Railway (nixpacks)

Configuración local

Requisitos previos

Node.js ≥ 22
Clúster MongoDB Atlas (o MongoDB local)
Redis (local o Upstash)

1. Clonar

git clone https://github.com/blinkboxhq/Blinkbox.git
cd Blinkbox
npm install

2. Configurar el entorno

cp apps/backend/.env.example apps/backend/.env

Edita apps/backend/.env: como mínimo necesitas:

MONGODB_URI=mongodb+srv://...
REDIS_URL=redis://localhost:6379
JWT_SECRET=your-32-char-secret
ENCRYPTION_KEY=your-exactly-32-char-key
ANTHROPIC_API_KEY=sk-ant-...          # enables the AI workflow builder behind create_automation

3. Ejecutar

# Terminal 1 — backend (port 3000)
cd apps/backend && npm run dev

# Terminal 2 — frontend (port 5174)
cd apps/frontend && npm run dev

Abre http://localhost:5174.

Variables de entorno

Obligatorias

Variable	Descripción
`MONGODB_URI`	Cadena de conexión de MongoDB
`REDIS_URL`	Cadena de conexión de Redis
`JWT_SECRET`	≥ 32 caracteres, cualquier cadena aleatoria
`ENCRYPTION_KEY`	Exactamente 32 caracteres: se usa para el cifrado AES del almacén de credenciales

IA (al menos una recomendada)

Variable	Descripción
`ANTHROPIC_API_KEY`	Habilita el constructor de flujos de IA (Claude) usado por la herramienta MCP `create_automation`
`GROQ_API_KEY`	LLM de respaldo (Llama 3.3 70B)
`GOOGLE_AI_KEY`	LLM de respaldo (Gemini 2.0 Flash)

Integraciones OAuth (opcionales)

Variable	Descripción
`GOOGLE_CLIENT_ID` / `GOOGLE_CLIENT_SECRET`	OAuth de Gmail, Drive, Calendar
`SLACK_CLIENT_ID` / `SLACK_CLIENT_SECRET`	OAuth de Slack
`GITHUB_CLIENT_ID` / `GITHUB_CLIENT_SECRET`	OAuth de GitHub
`MICROSOFT_CLIENT_ID` / `MICROSOFT_CLIENT_SECRET`	OAuth de Microsoft 365
`NOTION_CLIENT_ID` / `NOTION_CLIENT_SECRET`	OAuth de Notion
`AIRTABLE_CLIENT_ID` / `AIRTABLE_CLIENT_SECRET`	OAuth de Airtable

Despliegue

Variable	Descripción
`BACKEND_PUBLIC_URL`	URL pública del backend (p. ej. `https://api.blinkbox.net`): obligatoria para las devoluciones de llamada OAuth
`FRONTEND_URL`	URL del frontend para la lista de permitidos CORS
`PORT`	Puerto del backend (predeterminado: 3000)

Arquitectura

┌─────────────────────────────────────────────────────┐
│                    Frontend (Vite)                  │
│  Dashboard · Workspace Canvas · MCP keys            │
└───────────────────────┬─────────────────────────────┘
                        │ REST API
┌───────────────────────▼─────────────────────────────┐
│                Backend (Express)                    │
│  Auth · Automations · Executions · Credentials      │
│  MCP server · AI builder · OAuth · Webhooks         │
└──────────┬──────────────────┬───────────────────────┘
           │                  │
    ┌──────▼──────┐    ┌──────▼──────┐
    │  MongoDB    │    │    Redis    │
    │  Atlas      │    │   Queues   │
    └─────────────┘    └──────┬──────┘
                              │
                    ┌─────────▼───────────┐
                    │  Execution Workers  │
                    │  (4 cursor cells)   │
                    │  Chromium pool      │
                    └─────────────────────┘

Motor de ejecución

Los flujos de trabajo se ejecutan como máquinas de estado basadas en cursores. Cada ejecución es un documento de MongoDB con una matriz de cursores. Los trabajadores reclaman cursores atómicamente mediante arrayFilters, ejecutan el controlador de nodo, avanzan el cursor y liberan. Las colas de Redis desacoplan la propagación de disparadores de la ejecución. Un proceso reanudador recupera las ejecuciones bloqueadas cada 5 segundos.

Sistema de nodos

Cada integración es un nodo con dos mitades:

Frontend (nodeRegistry.js): panel de configuración, icono, etiqueta, categoría
Backend (nodes/): controlador sin estado async (config, context) => result

La misma clave backendType conecta ambos lados. Hay más de 250 nodos registrados.

Constructor de flujos de IA

create_automation (la herramienta MCP) entrega tu descripción a un constructor del lado del servidor:

"Cuando llegue un nuevo pago de Stripe, busca al cliente en HubSpot y envía una alerta de Slack a #revenue"

El constructor llama a Claude con la base de conocimiento de nodos y uso forzado de herramientas, y devuelve un flujo de trabajo completamente configurado y correcto en el lienzo (valores de campo reales, encadenamiento de variables {{trigger.data.from}}, posiciones de nodos) como borrador que puedes ejecutar, inspeccionar y activar desde el agente o la interfaz.

Cadena de respaldo de proveedores: Anthropic → Groq → Gemini

Seguridad

Autenticación JWT en todas las rutas de API, consultas con ámbito de espacio de trabajo
Cifrado de credenciales AES-256-GCM (la clave nunca se almacena en la base de datos)
Protección SSRF en todas las solicitudes HTTP salientes
Entorno de pruebas de código: V8 aislado con límites de memoria/tiempo (isolated-vm)
Nodos de herramienta de shell restringidos detrás de ENABLE_SHELL_TOOLS=true (desactivados por defecto)
Tokenes de estado OAuth (protección CSRF), postMessage solo a orígenes explícitos
Limitación de velocidad en disparadores de webhook (respaldada por Redis, sobrevive a reinicios)

Despliegue en Railway

Crea un proyecto en Railway y añade el repositorio
Configura todas las variables de entorno obligatorias en el panel de Railway
Establece BACKEND_PUBLIC_URL con la URL de tu backend en Railway
Registra esa URL como URI de redirección OAuth en Google Cloud Console (si usas Gmail)

El nixpacks.toml en apps/backend/ instala Chromium y todas las dependencias nativas automáticamente.

Licencia

MIT