Spiderbrain API

Brain-as-a-Service for your whole org.

Point the Spiderbrain API at your projects and get one always-fresh, deterministic brain your team and its AI agents can plug into, over a single authenticated API or MCP. No local setup, no manual re-indexing, no guessing.

See pricing

In beta: every account can create an API key and use the API free, right now. Team-scale Brain-as-a-Service (shared org brains, roles, audit) ships with Cortex and Enterprise.

The middle layer for project intelligence

The API sits on top of every project. Commits, changes and actions flow through it; it keeps a structural brain of your codebase current as people work, and serves that brain to any AI system that asks. Your tools stop re-reading the whole codebase and start working from what actually matters.

One layer in the middle. Your projects on one side, your AI and tooling on the other, a single source of structural truth between them.

What the API gives you

Always-fresh brain

Ask for a project's brain and get a current one. The API detects when a project has changed and refreshes automatically. Your AI never works from a stale map.

Change-impact & blast radius

Know what a change breaks before you ship it. The API ranks the files and components a change reaches across the whole project, not just the file in front of you.

Predictable team merge

Many contributors, one shared brain. The API merges everyone's view of the same project deterministically and surfaces conflicts instead of guessing.

Governance & audit

Every action is scoped by role and recorded in an append-only, tamper-evident trail, so you can prove who accessed what and how a conclusion was reached.

Deterministic by design

Same input, same brain, every time. Results are reproducible and auditable: the property an agent needs from a memory it acts on.

Source-free

Only a source-free structural graph (paths, connections and signals) is ever stored. Your code and file contents are never kept.

API + MCP

Read a brain over a plain authenticated REST API, or connect it directly to your assistant as an MCP server. Same brain, whichever way your tools speak.

Org-scoped & isolated

Every brain, key and request is scoped to your organization and team, with hard isolation between tenants and per-org access control.

What you can build on it

Smarter coding agents

Give your agents structural context (what depends on what, what a change touches) so they edit with the whole system in mind, using a fraction of the tokens.

CI change-impact gates

Call the API in CI to flag high-blast-radius changes and route the right reviewers before a risky PR merges.

Architecture dashboards

Surface the keystones, the risk and the structure of any project to your team in a live internal view.

Org-wide context for assistants

Connect the brain to your IDE and chat assistants over MCP so every engineer's AI shares the same up-to-date map of the codebase.

Quickstart: use your API key

Create a key from your dashboard (Cloud Brain, then API Keys). The full key is shown once, right after you create it. A key is either account-wide or scoped to a single brain; a brain-scoped key automatically targets its brain and cannot read anything else.

API usage is free until 1 August 2026. Calls are metered and shown in your dashboard so you can see exactly what you use, and metered billing begins on that date. Nothing is charged before then.

1. Authenticate

Every request carries your key as a bearer token. The base URL is https://api.spiderbrain.ai.

curl https://api.spiderbrain.ai/v1/brains \
  -H "Authorization: Bearer sb_live_YOUR_KEY"

2. Read a brain

A brain is a scored, source-free structural graph of a project: files, connections, risk and keystone signals. No code, no file contents, ever.

curl https://api.spiderbrain.ai/v1/brains/my-project \
  -H "Authorization: Bearer sb_live_YOUR_KEY"

3. Or connect over MCP

The same key unlocks the hosted MCP server, so your assistant can query the brain directly. With Claude Code:

claude mcp add --transport http spiderbrain https://api.spiderbrain.ai/mcp \
  --header "Authorization: Bearer sb_live_YOUR_KEY"

Or in any MCP client that takes a JSON config:

{
  "mcpServers": {
    "spiderbrain": {
      "type": "http",
      "url": "https://api.spiderbrain.ai/mcp",
      "headers": { "Authorization": "Bearer sb_live_YOUR_KEY" }
    }
  }
}

Tools include spiderbrain_query, spiderbrain_search, spiderbrain_brief, spiderbrain_cascade (blast radius) and the memory and canvas tools.

Endpoints

Endpoint	What it does	Scope
`GET /v1/brains`	List your hosted brains (id, name, node and edge counts).	`query`
`GET /v1/brains/{id}`	Fetch a brain: the full source-free structural graph, scored. Accepts the brain id, name or slug.	`query`
`GET /v1/memory/tree`	The distilled memory layer for a brain: categories, memory items, provenance.	`memory`
`GET /v1/memory/stats`	Memory layer counts and freshness for a brain.	`memory`
`GET & POST /v1/memory/comments`	Read and add comments on memory sections.	`memory`
`GET & POST /v1/canvas`	Read and draw on a brain’s shared canvas.	`query`
`GET /v1/usage`	Your metered usage log. Account-wide keys with the billing:read scope only.	`billing:read`
`GET /v1/billing/wallet`	Included allowance and wallet balance. Account-wide keys with billing:read only.	`billing:read`
`POST /mcp`	The hosted MCP server. Same key, full tool surface (query, search, brief, cascade, memory and canvas tools).	`query`

New keys carry the query and memory scopes. Key management itself is dashboard-only by design: a leaked key can never mint more keys. Requests are rate limited to 60 per minute.

Put a brain behind your AI.

Tell us your stack and how your agents and CI consume context, and we will map the right setup on Cortex or Enterprise.

See all plans