REST API

innernet speaks two protocols over the same memory: an MCP endpoint for AI clients, and this REST API for the agents you build. They are at full parity — every tool a connected AI client can call has an HTTP twin here, running the same handler against the same data. What your agent writes over REST, the user's Claude, Cursor and ChatGPT read over MCP. What they save there, your agent reads here.

Base URL: https://innernet.live/api/v1. GET /api/v1 returns a discovery document — the standing guidance, the endpoint map, and the tool-parity table — so an agent can learn innernet without being handed documentation by a human.

start here#

One call. Pass the question you are actually trying to answer, and innernet returns the slice that matters rather than the whole map:

curl "https://innernet.live/api/v1/context?slug=my-project&intent=what+did+we+decide+about+pricing" \
  -H "Authorization: Bearer innernet_..."

You get back a spine (what this project is), focus (the sections that answer the ask, budgeted to ~1600 tokens), periphery (one-line summaries of everything else, with how to expand each), and retrieval_advice (what to read next). Plus a receipt: how much was sent, and how many private facts were withheld.

Reach for the specific endpoints below when you already know which page you want.

the families#

• Context — projects → dimensions → captures: the structured world-model innernet maintains.
• Versioning — commits, branches, diff, merge, handoffs: fork an idea-space, let an agent write to the branch, read exactly what changed, then merge or discard. The part no flat memory store can do.
• Memories — a flat, namespaced store for apps you build: scope rows to your own end-users, agents, and runs.
• Tasks — the user's checklist, the same rows their dashboard and their AI client see.
• Artifacts — living documents that re-organise themselves as findings land.
• Personal memory — who the user is, behind disclosure gates. private never crosses the wire, at any ceiling you ask for.

Plus ranked full-text search across all of it. The machine-readable spec lives at /api/v1/openapi.json.

authentication#

Mint an API key in your dashboard under connections → api. Keys are shown once, stored hashed, carry read and/or write scopes, and can be revoked individually (up to 10 active keys).

curl https://innernet.live/api/v1/projects \
  -H "Authorization: Bearer innernet_..."

OAuth 2.1 access tokens (the ones MCP clients hold) work on every endpoint too.

add and recall memories#

# remember something about one of YOUR users
curl -X POST https://innernet.live/api/v1/memories \
  -H "Authorization: Bearer innernet_..." \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Prefers concise answers; works in TypeScript.",
    "user_id": "user_42",
    "tags": ["preference"]
  }'

# recall them later
curl "https://innernet.live/api/v1/memories?user_id=user_42&limit=20" \
  -H "Authorization: Bearer innernet_..."

user_id, agent_id, and run_id are your namespaces — innernet keeps each end-user's memories separate under your account. metadata is free-form JSON; tags are filterable.

search everything#

curl "https://innernet.live/api/v1/search?q=pricing+decision" \
  -H "Authorization: Bearer innernet_..."

One query ranks across dimensions, nodes, captures, projects, and memories, returning highlighted snippets with kind + ref so you can fetch the source. Scope to one project with &project=slug.

read and write context#

# the full map
curl https://innernet.live/api/v1/projects/my-product \
  -H "Authorization: Bearer innernet_..."

# one dimension
curl https://innernet.live/api/v1/projects/my-product/dimensions/roadmap \
  -H "Authorization: Bearer innernet_..."

# replace it (writes a commit)
curl -X PUT https://innernet.live/api/v1/projects/my-product/dimensions/roadmap \
  -H "Authorization: Bearer innernet_..." \
  -H "Content-Type: application/json" \
  -d '{"content": "# Roadmap\n\n- ship v1", "commit_message": "trim roadmap"}'

# append a capture (consolidated into dimensions on next sync)
curl -X POST https://innernet.live/api/v1/projects/my-product/captures \
  -H "Authorization: Bearer innernet_..." \
  -H "Content-Type: application/json" \
  -d '{"content": "Decided: usage-based pricing.", "tags": ["decision"]}'

version everything: commits & branches#

This is the part no other memory API has. Every save and capture is a commit; a branch forks the whole context map so two versions of an idea can exist at once — then diff and merge when a direction wins.

# history
curl https://innernet.live/api/v1/projects/my-product/commits \
  -H "Authorization: Bearer innernet_..."

# fork the map at its current head
curl -X POST https://innernet.live/api/v1/projects/my-product/branches \
  -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \
  -d '{"name": "pricing-experiment", "summary": "what if usage-based?"}'

# work on the branch — trunk untouched
curl -X PUT https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/dimensions/pricing \
  -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \
  -d '{"content": "# Pricing\n\nUsage-based, $0.005/1k ops."}'

# what changed vs trunk?
curl https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/diff \
  -H "Authorization: Bearer innernet_..."

# the experiment won — fold it back (records a merge commit, bumps head)
curl -X POST https://innernet.live/api/v1/projects/my-product/branches/pricing-experiment/merge \
  -H "Authorization: Bearer innernet_..."

Not ready to decide? PATCH the branch with {"status": "parked"} — it's archived with its overlay intact, revivable any time. Merge semantics are branch-wins; conflict-aware merge is on the roadmap.

personal memory over the API#

The account owner's Self Map — atomic facts with disclosure classes — is readable and writable with the same key. private facts never cross the API, whatever ceiling you ask for.

# facts up to a disclosure ceiling (self | trusted | work | public)
curl "https://innernet.live/api/v1/self/facts?max_disclosure=work" \
  -H "Authorization: Bearer innernet_..."

# queue a fact-candidate (the consolidator distills it on next sync)
curl -X POST https://innernet.live/api/v1/self/capture \
  -H "Authorization: Bearer innernet_..." -H "Content-Type: application/json" \
  -d '{"content": "Prefers dark mode everywhere.", "dimension_hint": "preferences"}'

And any project load can carry the owner's context with it — GET /v1/projects/{slug}?include_self=1 appends a disclosure-gated personal_context slice, so an app you build knows how you work the moment it loads what you're working on.

errors & rate limits#

Every error is one shape:

{ "error": { "code": "not_found", "message": "Project not found: my-product" } }

CORS is open (Access-Control-Allow-Origin: *), so browser apps work — but never ship a write-scoped key to a browser; mint a read-only key instead.

endpoint reference#

parity — every tool, and the endpoint that mirrors it#

Each row is the same handler reached two ways. Nothing below is a re-implementation.

endpoint reference#