Blinkbox

Plataforma de automação open-source (alternativa ao Zapier / Make / n8n) exposta como um servidor MCP. Agentes listam, criam, executam, ativam e depuram fluxos de trabalho em mais de 250 integrações, scraping headless com Chromium e nós de JS em sandbox; inclui um SKILL.md com o catálogo de nós e a sintaxe de expressões. Hospedado (plano gratuito, chave de API) ou auto-hospedado.

GitHub
3
Experimente este MCPPatrocinado

Servidor MCP hospedado

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

Instala no Claude Code, Codex, Cursor e outros

Documentação

BlinkBox

Plataforma de automação de código aberto (alternativa ao Zapier / Make / n8n) com servidor MCP nativo — conecte Claude Code, Cursor ou ChatGPT e deixe o agente construir, executar e depurar seus fluxos de trabalho.

Camada gratuita hospedada em blinkbox.net (sem cartão) · auto-hospedado com Node 22 + MongoDB + Redis · MIT.

O que ela faz

  • Servidor MCP — toda a plataforma é exposta pelo Model Context Protocol (HTTP Streamable). Seu agente de codificação lista, cria, executa, ativa e depura fluxos de trabalho com chamadas de ferramentas — veja Usar no Claude Code
  • Habilidade do agente — uma SKILL.md que ensina ao agente os campos de nós, a sintaxe de expressões e as regras de execução, para que um fluxo funcional leve ~4 chamadas de ferramentas em vez de ~12 tentativas
  • Canvas de arrastar e soltar — tudo o que o agente constrói é um fluxo de trabalho normal que você pode abrir e editar visualmente
  • Agentes de IA — nós de LLM que raciocinam sobre dados e geram resultados estruturados
  • Raspagem headless — pool completo de Chromium, contorna anti-bot, renderiza JavaScript
  • Sandbox de código — escreva JavaScript em um sandbox V8 isolado com limites de memória
  • Mais de 250 integrações — Gmail, Slack, Stripe, GitHub, Notion, Airtable, Shopify e mais
  • Cofre de credenciais criptografado — AES-256-GCM; segredos nunca saem do servidor descriptografados

Use no Claude Code, Cursor ou ChatGPT (60 segundos)

  1. Cadastre-se em blinkbox.net → Dashboard → MCP → crie uma chave de API.

  2. Adicione o servidor ao seu 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>" }
    }
  }
}

    Clientes que não conseguem enviar cabeçalhos podem passar a chave na URL: https://mcp.blinkbox.net/mcp?key=<your key>.

  3. (Recomendado) instale a habilidade para que o agente conheça o catálogo de nós e a sintaxe de expressões:

    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

  4. Peça o que você quiser:

    "Todas as manhãs às 8h, encontre dentistas em Berlim no OpenStreetMap que listem site, e-mail e telefone, remova duplicatas da minha planilha do Google e adicione os novos."

    O agente chama create_automation, executa com run_automation, lê get_execution_logs quando algo falha e activate_automation quando está tudo certo. Aplicativos OAuth (Google, Slack, Notion…) são conectados uma vez por você no dashboard — o agente nunca vê seus tokens.

Ferramentas: 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

Auto-hospedando? O mesmo servidor está em <your backend>/api/mcp — crie chaves no seu próprio dashboard.

Stack

CamadaTecnologia
FrontendReact 18 + Vite + Tailwind CSS + ReactFlow
BackendNode.js + Express + MongoDB Atlas + Redis
IAAnthropic Claude (principal) → Groq → Gemini (fallback)
RaspagemPuppeteer + Chromium
ExecuçãoMotor distribuído baseado em cursor, 4 células de worker
ImplantaçãoRailway (nixpacks)

Configuração local

Pré-requisitos

  • Node.js ≥ 22
  • Cluster MongoDB Atlas (ou MongoDB local)
  • Redis (local ou Upstash)

1. Clonar

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

2. Configurar o ambiente

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

Edite apps/backend/.env — no mínimo você precisa de:

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. Executar

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

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

Abra http://localhost:5174.

Variáveis de ambiente

Obrigatórias

VariávelDescrição
MONGODB_URIString de conexão do MongoDB
REDIS_URLString de conexão do Redis
JWT_SECRET≥ 32 caracteres, qualquer string aleatória
ENCRYPTION_KEYExatamente 32 caracteres — usada para criptografia AES do cofre de credenciais

IA (pelo menos uma recomendada)

VariávelDescrição
ANTHROPIC_API_KEYHabilita o construtor de fluxos de IA (Claude) usado pela ferramenta MCP create_automation
GROQ_API_KEYLLM de fallback (Llama 3.3 70B)
GOOGLE_AI_KEYLLM de fallback (Gemini 2.0 Flash)

Integrações OAuth (opcionais)

VariávelDescrição
GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRETOAuth do Gmail, Drive, Calendar
SLACK_CLIENT_ID / SLACK_CLIENT_SECRETOAuth do Slack
GITHUB_CLIENT_ID / GITHUB_CLIENT_SECRETOAuth do GitHub
MICROSOFT_CLIENT_ID / MICROSOFT_CLIENT_SECRETOAuth do Microsoft 365
NOTION_CLIENT_ID / NOTION_CLIENT_SECRETOAuth do Notion
AIRTABLE_CLIENT_ID / AIRTABLE_CLIENT_SECRETOAuth do Airtable

Implantação

VariávelDescrição
BACKEND_PUBLIC_URLURL pública do backend (ex.: https://api.blinkbox.net) — necessária para callbacks OAuth
FRONTEND_URLURL do frontend para a lista de permissões CORS
PORTPorta do backend (padrão: 3000)

Arquitetura

┌─────────────────────────────────────────────────────┐
│                    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 execução

Os fluxos de trabalho rodam como máquinas de estado baseadas em cursor. Cada execução é um documento MongoDB com um array de cursores. Os workers reivindicam cursores atomicamente via arrayFilters, executam o handler do nó, avançam o cursor e liberam. Filas Redis desacoplam o fan-out de gatilhos da execução. Um processo resumidor recupera execuções travadas a cada 5 segundos.

Sistema de nós

Cada integração é um nó com duas metades:

  • Frontend (nodeRegistry.js) — painel de configuração, ícone, rótulo, categoria
  • Backend (nodes/) — handler sem estado async (config, context) => result

A mesma chave backendType conecta os dois lados. Mais de 250 nós estão registrados.

Construtor de fluxos com IA

create_automation (a ferramenta MCP) entrega sua descrição a um construtor no servidor:

"Quando um novo pagamento do Stripe chegar, busque o cliente no HubSpot e envie um alerta no Slack para #revenue"

O construtor chama o Claude com a base de conhecimento de nós e uso forçado de ferramentas, e retorna um fluxo totalmente configurado e correto para o canvas — valores reais de campos, encadeamento de variáveis ({{trigger.data.from}}), posições de nós — como um rascunho que você pode executar, inspecionar e ativar pelo agente ou pela interface.

Cadeia de fallback de provedores: Anthropic → Groq → Gemini

Segurança

  • Autenticação JWT em todas as rotas de API, consultas com escopo por workspace
  • Criptografia de credenciais AES-256-GCM (chave nunca armazenada no banco)
  • Proteção SSRF em todas as requisições HTTP de saída
  • Sandbox de código: V8 isolado com limites de memória/tempo (isolated-vm)
  • Nós de ferramenta de shell protegidos por ENABLE_SHELL_TOOLS=true (desativados por padrão)
  • Tokens de estado OAuth (proteção CSRF), postMessage apenas para origens explícitas
  • Limitação de taxa em gatilhos de webhook (com suporte a Redis, sobrevive a reinicializações)

Implantação no Railway

  1. Crie um projeto no Railway e adicione o repositório
  2. Defina todas as variáveis de ambiente obrigatórias no dashboard do Railway
  3. Defina BACKEND_PUBLIC_URL para a URL do seu backend no Railway
  4. Registre essa URL como URI de redirecionamento OAuth no Google Cloud Console (se usar Gmail)

O nixpacks.toml em apps/backend/ instala o Chromium e todas as dependências nativas automaticamente.

Licença

MIT