Como conectar o Cursor a um browser real via CDP — capa ilustrada do artigo Clawbrowser

Como conectar o Cursor a um browser real via CDP

Clawbrowser Teamagentes-de-iacdpcursortutorial

O browser integrado do Cursor ajuda quando você está inspecionando sua própria aplicação. Ele navega, clica, digita e tira screenshots. Mas ele roda como uma webview isolada: sem cookies realmente persistentes, sem fingerprint confiável e sem caminho claro para sites que validam identidade do browser.

TL;DR: conecte o Cursor ao Clawbrowser via CDP (Chrome DevTools Protocol). Seu agente passa a usar um Chromium real com perfis persistentes, fingerprints gerenciados e proxy routing. A configuração é curta: instalar, iniciar um perfil e apontar o Cursor para o endpoint local.

Por que o browser integrado do Cursor não basta

O Cursor vem com uma ferramenta de browser baseada em uma webview sandboxed exposta por um MCP server. Para localhost, ela resolve: navigate, click, type, scroll, screenshot, console output e network traffic.

Para qualquer fluxo fora do ambiente local, os limites aparecem:

Limitação O que acontece
Webview isolada Não é uma instância Chromium real. Sites detectam APIs ausentes e propriedades de window fora do padrão.
Sem persistência de sessão Cookies e localStorage ficam presos ao workspace e podem sumir entre sessões.
Sem gerenciamento de fingerprint O mesmo canvas hash, WebGL renderer e navigator properties aparecem em toda execução.
Sem proxy support Todo tráfego sai pelo IP padrão da máquina. IPs de datacenter são marcados rápido.
Problemas de confiabilidade Versões 2.3.18+ do Cursor trouxeram regressões em click, scroll e busca de elementos.

Se o agente precisa fazer login, coletar dados atrás de Cloudflare ou operar um fluxo multi-step em produção, a webview integrada vira gargalo.

O que CDP entrega

CDP (Chrome DevTools Protocol) é a interface padrão para controlar browsers Chromium por código. Playwright chama connectOverCDP, Puppeteer chama puppeteer.connect e clientes CDP abrem um WebSocket para a porta de debugging.

Ao conectar o Cursor a um browser externo via CDP, você ganha:

  • Um browser real com engine de renderização completo, extensões e APIs padrão
  • Sessões persistentes com cookies e login que continuam entre execuções
  • Controle total da página pelo mesmo protocolo usado por Playwright e Puppeteer
  • Anti-detection quando o browser gerencia fingerprint e proxy como uma identidade coerente

A conexão é uma URL WebSocket comum. Qualquer ferramenta que fale CDP pode se conectar a um browser que expõe endpoint CDP. O Clawbrowser expõe um em cada perfil.

Conectando o Cursor ao Clawbrowser: passo a passo

Pré-requisitos

  • macOS (Apple Silicon), Linux (x64 ou arm64) ou Windows
  • Cursor instalado
  • Uma API key do Clawbrowser em app.clawbrowser.ai

Passo 1: instalar o Clawbrowser

Baixe e extraia o bootstrapper clawctl:

# macOS (Apple Silicon)
archive="clawctl-macos-arm64.tar.gz"
curl -fL --retry 3 -o "$archive" \
  "https://github.com/clawbrowser/clawctl/releases/latest/download/${archive}"
tar -xzf "$archive"

No Linux, use clawctl-linux-amd64.tar.gz ou clawctl-linux-arm64.tar.gz. Não precisa de Docker nem sudo.

Configure sua API key:

./clawctl config set api-key

Passo 2: iniciar um perfil de browser

Inicie o Clawbrowser com um perfil nomeado. Cada perfil recebe seu próprio fingerprint, armazenamento de cookies e proxy opcional:

# Start a profile and open the verification page
clawctl start --profile cursor-dev --url clawbrowser://verify/ --json

# Get the CDP endpoint for this profile
clawctl endpoint --profile cursor-dev --json

O comando endpoint retorna uma URL como http://127.0.0.1:9222. Esse é o endpoint CDP que o agente do Cursor vai usar.

Passo 3: conectar pelo Cursor via MCP

A integração mais simples usa o MCP server integrado do Clawbrowser. Ele expõe navegação, screenshots, clicks, gerenciamento de abas e inicialização de perfis como ferramentas MCP que o Cursor pode chamar diretamente. O server cuida do CDP internamente.

Rode o instalador para gravar a configuração MCP local:

clawctl install --agent all --json

O Cursor passa a carregar esse MCP server pela configuração.

Alternativa: Microsoft Playwright MCP

Se você prefere o servidor oficial Microsoft Playwright MCP, aponte para o endpoint CDP do Clawbrowser em Cursor Settings > MCP > Add Server:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [

Os dois caminhos dão ao Cursor acesso de alto nível ao browser. O MCP server do Clawbrowser adiciona gerenciamento de perfis e fingerprints em cima das ações padrão.

Passo 4: verificar a conexão

Peça para o agente do Cursor abrir uma página de teste:

Navigate to https://browserleaks.com/canvas and take a screenshot. Tell me what canvas fingerprint hash you see.

Se a conexão estiver certa, você verá um canvas fingerprint real do perfil gerenciado pelo Clawbrowser, não o hash genérico da webview.

Conexão CDP direta a partir do código

Se o agente do Cursor escreve e executa scripts em vez de usar ferramentas MCP, conecte diretamente com Playwright ou Puppeteer:

Playwright (Python)

from playwright.async_api import async_playwright

async def browse_with_clawbrowser():
    async with async_playwright() as p:
        # Connect to Clawbrowser's CDP endpoint

Playwright (Node.js)

const { chromium } = require('playwright');

const browser = await chromium.connectOverCDP('http://127.0.0.1:9222');
const page = browser.contexts()[0].pages()[0];

Puppeteer

const puppeteer = require('puppeteer');

const browser = await puppeteer.connect({
  browserURL: 'http://127.0.0.1:9222'
});

Os três frameworks conectam no mesmo endpoint CDP. O Clawbrowser cuida da camada de identidade: Canvas, WebGL, AudioContext, fontes, resolução, timezone, navigator properties e proxy routing ficam coerentes dentro do perfil.

Por que anti-detection importa para agentes Cursor

Quando seu agente Cursor navega com um browser padrão, sistemas anti-bot verificam a identidade em várias superfícies:

Sinal O que é verificado Chrome padrão Clawbrowser
Canvas hash GPU rendering fingerprint Static, matches known automation profiles Unique per profile, consistent with reported GPU
WebGL renderer Graphics card identifier Exposes real hardware Matches the profile's simulated hardware
Navigator properties Browser version, platform, language Generic Chromium values Consistent with profile's OS and locale
Timezone System timezone vs IP geo Mismatches with proxy location Auto-aligned with proxy geography
CDP detection Runtime.enable traces Detectable via leaked CDP artifacts Engine-level patches suppress CDP signals

Instâncias Chromium comuns conectadas por CDP deixam sinais que anti-bot detecta em segundos. O Clawbrowser corrige isso no nível do engine, não com overrides JavaScript fáceis de identificar.

Essa é a diferença entre conectar o Cursor a chrome --remote-debugging-port=9222, que tende a ser bloqueado, e conectar ao Clawbrowser, que mantém uma identidade consistente.

Gerenciando múltiplos perfis

Cada perfil do Clawbrowser é isolado. Rode vários perfis ao mesmo tempo para contas ou projetos diferentes:

# Create three profiles with different locations
clawctl create --profile account-a --location sweden --json
clawctl create --profile account-b --location germany --json
clawctl create --profile account-c --location japan --json

Cada perfil recebe fingerprint único, IP de proxy próprio e storage isolado. Para a plataforma, parecem usuários independentes em máquinas e países diferentes.

O agente do Cursor pode alternar perfis conectando em endpoints CDP diferentes, ou controlar vários em paralelo a partir do mesmo script.

Browser integrado do Cursor vs CDP vs Clawbrowser

Cursor integrado Chrome via CDP Clawbrowser via CDP
Browser engine Sandboxed webview Real Chromium Real Chromium (patched)
Session persistence Workspace-scoped Manual profile dirs Named profiles with auto-persistence
Fingerprint management None None 20+ surfaces managed per profile
Proxy support None Manual flag Profile-bound, geo-aligned
Anti-bot survival Blocked instantly Blocked within minutes Passes Cloudflare, DataDome, PerimeterX
Multi-account Not possible Separate --user-data-dir Built-in profile isolation
Setup complexity Zero (built in) Moderate Three commands

Use o browser integrado para inspecionar sua própria app em localhost. Use Clawbrowser via CDP para qualquer coisa que toque a web real.

FAQ

Isso funciona com o agent mode do Cursor?

Sim. O agent mode do Cursor pode usar qualquer MCP server, inclusive servidores que conectam em browsers externos via CDP. O agente chama as ferramentas MCP como chamaria o browser integrado, mas as ações rodam no Clawbrowser.

Preciso instalar Playwright ou Puppeteer?

Só se o agente escreve e executa scripts de automação. No fluxo MCP, o server gerencia a conexão CDP internamente e o agente usa ações como "navigate" e "click".

Posso reutilizar sessões de login entre projetos Cursor?

Sim. Perfis Clawbrowser persistem cookies, localStorage e IndexedDB. Inicie um perfil, faça login manualmente ou com o agente e reutilize o perfil depois.

E se a ferramenta de browser do Cursor conflitar com o browser externo?

Desative o browser integrado em Settings > Features > Browser se quiser evitar confusão. Os dois também podem coexistir: são independentes.

O Clawbrowser é grátis?

Sim. Clawbrowser é grátis, open source e MIT-licensed. Sem cobrança por seat, sem limite de uso, sem assinatura do runtime. Você precisa de uma API key de app.clawbrowser.ai para validar a instalação.

Comece

Três comandos para conectar seu agente Cursor a um browser real:

# Install Clawbrowser
clawctl install --json

# Set your API key
clawctl config set api-key

Aponte seu MCP server ou script Playwright para o endpoint retornado. O agente do Cursor passa a navegar com fingerprints gerenciados, sessões persistentes e proxy routing.

Para saber mais sobre CDP, leia Navegador CDP para agentes de IA: guia do desenvolvedor. Para fingerprinting, leia Impressão digital do navegador: 20 sinais anti-bot.

Continue lendo

Artigos relacionados

Ver todos →
CDP vs MCP: quando usar cada um para controle de browser por IA — capa ilustrada do artigo Clawbrowser

CDP vs MCP: quando usar cada um para controle de browser por IA

CDP controla o browser. MCP conecta a IA. Saiba quando usar Chrome DevTools Protocol vs Model Context Protocol para automação de browser com agentes de IA.

Ler artigo →
Navegador CDP para agentes de IA: Um Guia de Desenvolvedor — capa de artigo ilustrada do Clawbrowser

Navegador CDP para agentes de IA: Um Guia de Desenvolvedor

Chrome DevTools Protocol é a forma padrão como agentes de IA controlam navegadores. Chrome padrão é detectado. Aqui está como conectar seu agente a um navegador CDP que não fica bloqueado.

Ler artigo →
← Voltar para todos os artigos