Enoki

Teste seus agentes de IA e servidores MCP em busca de vulnerabilidades de segurança e proteção, e verifique novamente as correções.

Ver em enokilabs.ai

Servidor MCP hospedado

npx add-mcp 'https://mcp.enokilabs.ai/mcp'

Instala no Claude Code, Codex, Cursor e outros

Documentação

Connect your agent

Wire your coding agent to the Enoki MCP server and register your first target.

Connect your coding agent to the Enoki MCP server, then register your first target. Claude Code, Codex, VS Code, Claude Desktop, claude.ai, ChatGPT, Cursor, and other MCP-capable clients all work.

[!NOTE]

Endpoint: https://mcp.enokilabs.ai/mcp (streamable HTTP).

Two ways to connect

  • Sign in. Claude Code, Codex, VS Code, Claude Desktop, claude.ai and ChatGPT connect by signing in: Enoki opens in your browser, you check what the app asks to do, untick what it doesn't need, and allow it. Approving takes an owner or admin of an Enoki workspace: an account that isn't in a workspace yet, or is on a self-serve trial, can't approve, and Troubleshooting says what to do. If you're in more than one workspace, you choose the one it connects to. The connection then shows under that workspace's Settings → Connected apps, where you can change or end it. Allow only a sign-in you just started yourself; if you didn't, click Deny.
  • An API key. A client that lets you set a request header can send a workspace API key instead, and Cursor and other clients that can't sign in need one. Give it the read and write scopes, plus test:run if your agent should start or stop assessments or re-test fixes. See API keys & scopes for how to mint one (workspace owners and admins only). Keys look like egk_… and are shown once.

[!WARNING]

The full setup flow needs both read and write (write does not imply read), plus test:run to trigger runs. Allow or grant the least you need.

Connect your client

Pick your client:

[tab] Claude Code

One command. --scope user makes the server available in every project, not just the current one:

claude mcp add --scope user --transport http enoki https://mcp.enokilabs.ai/mcp

Then run /mcp in a session and authenticate enoki. Enoki opens in your browser and says your answer goes to An app on this computer: check what Claude Code asks to do, untick anything it shouldn't have, and click Allow.

To connect with an API key instead, send it as a header:

claude mcp add --scope user --transport http enoki \
  https://mcp.enokilabs.ai/mcp \
  --header "Authorization: Bearer egk_your_key_here"

Verify with claude mcp list (or /mcp inside a session). The tools appear as mcp__enoki__get_setup_guide, mcp__enoki__create_target, and so on.

[tab] Codex

One command. Codex signs in right away: Enoki opens in your browser and says your answer goes to An app on this computer. Check what Codex asks to do, untick anything it shouldn't have, and click Allow.

codex mcp add enoki --url https://mcp.enokilabs.ai/mcp

The Codex IDE extension uses the same configuration. To sign in again later, run codex mcp login enoki. If Codex says the server does not support dynamic client registration, update Codex, or connect with an API key.

To connect with an API key instead, keep it in an environment variable and give Codex the variable's name:

export ENOKI_API_KEY=egk_your_key_here
codex mcp add enoki --url https://mcp.enokilabs.ai/mcp \
  --bearer-token-env-var ENOKI_API_KEY

Verify with codex mcp list.

[tab] Cursor

Cursor connects with an API key. Add Enoki to your ~/.cursor/mcp.json (global) or a project .cursor/mcp.json:

{
  "mcpServers": {
    "enoki": {
      "url": "https://mcp.enokilabs.ai/mcp",
      "headers": {
        "Authorization": "Bearer egk_your_key_here"
      }
    }
  }
}

Cursor picks it up; turn Enoki on or off under Customize in the sidebar.

[tab] VS Code

Add Enoki to .vscode/mcp.json in your project, or run MCP: Open User Configuration to have it in every workspace:

{
  "servers": {
    "enoki": {
      "type": "http",
      "url": "https://mcp.enokilabs.ai/mcp"
    }
  }
}

Start it with MCP: List Servers (pick enoki, then Start Server), or by using it in Chat. VS Code asks to authenticate to Enoki; allow it, and Enoki opens in your browser: check what VS Code asks to do, untick anything it shouldn't have, and click Allow.

To connect with an API key instead, let VS Code ask for it once, so it stays out of the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "enoki-key",
      "description": "Enoki API key",
      "password": true
    }
  ],
  "servers": {
    "enoki": {
      "type": "http",
      "url": "https://mcp.enokilabs.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${input:enoki-key}"
      }
    }
  }
}

[tab] Other clients

Zed, Goose and OpenCode (from version 2) sign in the same way: add the endpoint, and allow the sign-in when Enoki opens in your browser. A client that adds servers from the MCP Registry finds Enoki there as ai.enokilabs/enoki.

A client that can't sign in to Enoki says so: it reports that the server does not support dynamic client registration. Connect it with an API key instead, sent as the header Authorization: Bearer egk_your_key_here. A client that only runs local servers can reach Enoki through mcp-remote:

{
  "mcpServers": {
    "enoki": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://mcp.enokilabs.ai/mcp",
        "--header", "Authorization: Bearer egk_your_key_here"
      ]
    }
  }
}

[tab] Claude Desktop / claude.ai

Enoki is in Claude's connector directory: open Enoki in Claude and connect it. The connector runs on Anthropic's servers rather than your machine, so it also works from claude.ai and mobile.

To add it as a custom connector instead, go to Customize → Connectors → Add custom connector, name it Enoki, and set the URL to https://mcp.enokilabs.ai/mcp. On a Team or Enterprise plan, an Owner adds it for the organization under Organization settings → Connectors, and you then connect it from Customize → Connectors. If Claude asks how to sign in, pick a sign-in option with Use Claude's published identity as the OAuth client; Enoki doesn't support Register automatically. When you connect, Enoki opens in your browser: check what Claude asks to do, untick anything it shouldn't have, and click Allow.

To connect with an API key instead:

FieldValue
AuthenticationNo sign-in
Request headersAuthorization → Bearer egk_your_key_here

Claude offers request headers to some organizations only. If the dialog has no Request headers section, connect by signing in instead.

Under Advanced, Transport is detected as Streamable HTTP. Leave it.

[tab] ChatGPT

Open Enoki in ChatGPT and connect it. Enoki opens in your browser and says your answer goes to chatgpt.com: check what ChatGPT asks to do, untick anything it shouldn't have, and click Allow.

Connected apps

Workspace owners and admins see every app connected to the workspace under Settings → Connected apps: what it may do, who connected it and when, and when it was last used. Change what an app may do there, which applies from its next request, or disconnect it, which refuses its next request.

On the consent page, and when you change what an app can do, read shows as See targets, runs and findings, write as Add targets, edit target profiles and close findings, and test:run as Start and stop assessments, and re-test fixes.

An app always gets read. When it connects, write and test:run start ticked if the app asks for them, and it keeps whichever stay ticked. A connection ends by itself after 30 days without use, and 90 days after it was approved at the latest; the app then asks you to sign in again. It also ends when the person who approved it leaves the workspace or stops being an owner or admin.

Register your first target

A target is one of your agent endpoints or MCP servers, registered so Enoki can test it. The steps below register an agent; for an MCP server, see Register an MCP server. Your agent builds the config from your endpoint's own API docs; start with get_setup_guide, which ships the full field reference and worked examples.

1. Read the setup guide

Call get_setup_guide. It returns the config field reference plus the semantics the schema can't express (dot-paths, request-body templating, streaming modes, session capture) and worked examples for HTTP, SSE, and WebSocket endpoints.

2. Check for duplicates

Call list_targets first. Creates aren't deduplicated, so a matching name and endpoint_host in the same environment is the same target; reuse its model_id rather than making a second. If only the name or only the host matches, confirm before creating. list_targets returns at most 50 targets unless you raise limit (up to 200): when truncated is true, raise it before you decide nothing matches.

3. Create the target

Call create_target with a name, your config (endpoint_url, the response_field dot-path to the reply, transport, …) and the environment the agent runs in (prod, staging or dev; staging if you leave it out). It's atomic prove-then-persist: Enoki fires one live probe and saves the target only if it succeeds. On failure it returns a category (invalid_url, unreachable, auth_failed, parse_error, no_reply, not_an_endpoint, unknown) and saves nothing, so fix and retry (see Troubleshooting). A target's connection has no update or delete over MCP: in the Enoki app, a workspace owner or admin changes it on the target's page (Edit integration) or deletes the target from the inventory.

[!NOTE]

Only have a chat page? Pass the url of a page of yours instead of a config. A headless browser finds the agent call behind it: you get back status=discovering with a discovery_token, or status=not_a_page when the URL is not a web page Enoki can open, such as an API endpoint, which goes in a config instead. Poll get_target_discovery until its status is completed or failed. Once it has completed, call create_target with the token and a name, plus the candidate index when it lists more than one, to confirm and save. Any session the page sets up stays on the server.

[!NOTE]

Agent needs a key? create_target asks for no keys, tokens or passwords. Add an agent that needs one in the Enoki app, as a workspace owner or admin: open app.enokilabs.ai/inventory and choose Add integration, then AI agent. The app stores the key encrypted (OAuth client credentials included, and the token is re-minted before it expires). Your MCP client then finds the agent with list_targets and runs it with trigger_assessment. From CI, the REST API's POST /api/v1/model also takes the key (see the API reference).

[!NOTE]

Testing an MCP server? Pass an mcp object in place of config. A server without sign-in is tested and saved the same way; for one that signs in, create_target returns a link where its key is added in the Enoki app. See Register an MCP server.

4. Tell Enoki what the agent is for

Read the target's profile with get_target_profile and change it with update_target_profile, which also creates it when the target has none yet. Say what each type of user may see (user_access), which user the test account is (test_account) and which data is public (public_data). Only an answer you wrote or confirmed can rule a finding out, so data your test user may see is not reported as a leak. If auto-discovery has run on the target, what it found is labelled as its own until you confirm it with confirm_target_profile. Every text value comes back fenced as untrusted data; send exactly the text between the fence tags when you change or confirm it.

5. Run an assessment

With the model_id from create_target or list_targets, call trigger_assessment. It returns a run_id at once; poll get_assessment_status until status is no longer running, passing min_severity for a pass/fail verdict. cancel_run stops a run you no longer need, and its verdict then covers only the categories it completed. Then read results with list_findings (filter by run_id) and get_finding. Once you have fixed a finding, close it as fixed with close_finding and call validate_fix to re-run its attacks and confirm the fix. An MCP server's findings can't be re-tested yet; run a new assessment to confirm a fix. See the MCP tool reference.

Register an MCP server

Your agent can also register an MCP server you own, for Enoki to test for security weaknesses. A key the server needs is added in the Enoki app, never in the chat. See Connect your MCP server.

Scoped, change-relevant runs

A run without categories isn't limited to chosen categories. To gate a frequent deploy, focus the run on the categories a change actually touches: list the categories, pick the relevant subset, pass those keys to the trigger. A focused run concentrates on those categories rather than finishing sooner, and it can still report a finding outside them, which counts toward its min_severity verdict. An MCP server's run always covers all of its categories, so it takes none.

Listing the categories is part of the platform plan. On a trial workspace the REST listing answers 403 with code taxonomy_not_included, and a REST trigger that passes categories answers 403 with code trial_focus_not_included. Over MCP, list_categories and trigger_assessment refuse the same calls with a tool error that says why. Either way, run the full assessment instead.

1. List the categories

MCP: call list_categories. REST: GET /api/v1/category (scope read). Each entry carries a key, a display_name, and a description. The description is what makes an automated choice viable, so hand your agent the whole list rather than a name-only summary. The response is static platform metadata and is cacheable for an hour.

2. Trigger with the subset

Pass the chosen keys as categories to trigger_assessment (MCP) or POST /api/v1/run (REST), then poll as usual.

What's next

[card] What we test for

The coverage summary behind the category catalogue.

[card] Connect your MCP server

Register an MCP server you own, and add its key in the Enoki app.

[card] MCP tool reference

Every tool, what it does, and the scope each requires.

[card] Troubleshooting

Probe error categories, pending MCP targets, auth failures (401/403), and rate limits.

This documentation is built and hosted on Mintlify, a developer documentation platform.