Connect your agent

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

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

Two ways to connect

Sign in. Claude Code, Codex, VS Code, Claude Desktop and claude.ai 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 a workspace owner or admin, and the connection then shows under 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. Every client 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 trigger assessments. See API keys & scopes for how to mint one (workspace admins only). Keys look like egk_… and are shown once.

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:

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.

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.

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 from Settings → MCP; the Enoki tools show as connected.

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: 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}"
      }
    }
  }
}

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 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"
      ]
    }
  }
}

Add Enoki as a custom connector. The connector runs on Anthropic’s servers rather than your machine, so it also works from claude.ai and mobile.Go to Settings → Connectors → Add custom connector, name it Enoki, and set the URL to https://mcp.enokilabs.ai/mcp. Leave Authentication as Claude detects it. 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:

Field	Value
Authentication	None
Additional request headers	`Authorization` → `Bearer egk_your_key_here`

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

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. 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, registered so Enoki can test it. 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.

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.

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.

Create the target

Call create_target with your config. 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; change it in the Enoki app.

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 and returns a discovery_token; poll get_target_discovery, then call create_target with the token to confirm and save. Any session the page sets up stays on the server.

Agent needs a key? create_target asks for no keys, tokens or passwords. Add an agent that needs one in the Enoki app: open app.enokilabs.ai/inventory and choose Add integration. 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).

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.

Run an assessment

With the model_id from create_target, call trigger_assessment, poll get_assessment_status, then read results with list_findings and get_finding. See the MCP tool reference.

Scoped, change-relevant runs

A full assessment covers the whole security taxonomy. To gate a frequent deploy on something faster, focus the run on the categories a change actually touches: list the categories, pick the relevant subset, pass those keys to the trigger. Listing the categories is part of the platform plan. On a trial workspace the listing answers 403 with code taxonomy_not_included, and a trigger that passes categories answers 403 with code trial_focus_not_included, so run the full assessment instead.

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.

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

What we test for

The coverage summary behind the category catalogue.

MCP tool reference

Every tool, its inputs and outputs, and the scope each requires.

Troubleshooting

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

Get started

Connect

Integrations

MCP

REST API

Two ways to connect

Connect your client

Connected apps

Register your first target

Scoped, change-relevant runs

What’s next

What we test for

MCP tool reference

Troubleshooting

​Two ways to connect

​Connect your client

​Connected apps

​Register your first target

​Scoped, change-relevant runs

​What’s next

What we test for

MCP tool reference

Troubleshooting

Two ways to connect

Connect your client

Connected apps

Register your first target

Scoped, change-relevant runs

What’s next