API — Kanbanboard for developers & AI agents

Overview

The Kanbanboard API is a single HTTPS endpoint that an external program — an AI agent, an automation, a one-off script — calls with an organisation API key. It can list, create, rename and delete mind maps, and add, edit, connect and remove the thoughts (nodes) on them.

One endpoint, one key. No SDK to install — any HTTP client works.
Live by default. Anything the API writes shows up instantly for teammates watching the board.
Scoped to one organisation. A key can only ever touch its own org's data.
Built for agents. Bulk actions let an agent lay down a whole map in a single call.

Quickstart

From zero to a live map in three steps.

1

Create a key

In the app, open Members & invites → API keys and create one. You'll see the key once — copy it.

2

Make your first call

POST an action to /api/agent with your key in the Authorization header.

3

Watch it appear

Open the Mind Map tab — the map your agent just made is already there, live.

cURL

# Create a mind map
curl -s https://www.kanbanboard.com.au/api/agent \
  -H "Authorization: Bearer kbk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"action":"create_map","params":{"title":"Release plan"}}'

Getting a key

API keys are created by an organisation owner or admin inside the app — open the user menu, choose Members & invites, and use the API keys section to create one. Name it after whatever will use it (e.g. “Planning agent”).

The full key — it starts with kbk_ — is shown exactly once, at creation. Store it somewhere safe immediately; it can't be retrieved again, only replaced. You can revoke a key from the same screen at any time, and it stops working instantly.

Authentication

Every request carries your key as a bearer token:

Header

Authorization: Bearer kbk_your_key_here

Always call the www host: https://www.kanbanboard.com.au. The bare domain redirects to www, and HTTP clients drop the Authorization header across that redirect — so a call to the apex domain arrives with no key and gets a confusing 401.

Requests

One endpoint handles everything. Send a POST with a JSON body naming an action and its params.

POST https://www.kanbanboard.com.au/api/agent

Request body

{ "action": "create_node", "params": { "mapId": "…", "text": "An idea" } }

Responses are JSON. Coordinates are a free canvas — x grows right, y grows down; siblings read well about 220px apart across and 90px down. color is an optional hex accent like #10b981. update_node writes only the fields you send, so an agent edit never clobbers a teammate's live change.

Building a whole map? Use the bulk actions create_nodes and create_edges — one call each, and the map appears at once instead of trickling in node by node.

Maps

list_maps

List every mind map in the organisation, newest first.

Params: none
Returns: { maps: [{ id, title, updatedAt }] }

create_map

Create a new, empty map.

Params: title — 1–200 chars
Returns: { map }

rename_map

Change a map's title.

Params: mapId, title
Returns: { map }

get_map

Fetch a map's full state — title, every node, every edge. Read this before editing.

Params: mapId
Returns: { map, nodes, edges }

delete_map

Permanently delete a map and everything on it. This can't be undone.

Params: mapId
Returns: { ok: true }

Nodes

A node is one thought on the canvas.

create_node

Add one thought to a map.

Params: mapId, text (≤4000), x?, y?, color?
Returns: { node }

create_nodesBulk

Add up to 100 thoughts in one call — the whole batch appears at once.

Params: mapId, nodes: [{ text, x?, y?, color? }] (1–100)
Returns: { nodes } in input order

update_node

Change only the fields you pass on one node — safe alongside a human editing the same map.

Params: nodeId + any of text, x, y, color
Returns: { node }

delete_node

Delete one node; edges touching it are removed automatically.

Params: nodeId
Returns: { ok: true }

Edges

An edge is a connection between two nodes on the same map.

create_edge

Connect two existing nodes. Both must be on the same map; a node can't connect to itself.

Params: mapId, sourceId, targetId
Returns: { edge }

create_edgesBulk

Create up to 200 connections in one call — ideal right after a bulk create_nodes.

Params: mapId, edges: [{ sourceId, targetId }] (1–200)
Returns: { edges }

delete_edge

Remove one connection; the nodes themselves are untouched.

Params: edgeId
Returns: { ok: true }

Errors & limits

Errors come back as { "error": "…" } with a standard HTTP status.

Status	Meaning
400	The request or a parameter was invalid — the message says which.
401	Missing, malformed, or revoked key (or a call to the apex domain — see Authentication).
404	The map, node, or edge doesn't exist in this key's organisation.
429	Rate limited — you're going too fast.
500	Something went wrong on our side. Retry in a moment.

Rate limit

Up to 240 requests per minute per key. A bulk call counts as one request — another reason to prefer create_nodes / create_edges when building.

MCP & AI agents

The whole API is also available as a Model Context Protocol (MCP) server, so you can plug it straight into Claude, Claude Code, or any MCP-capable agent. Point the server at your key and the twelve actions above show up as native tools the agent can call — no glue code. The agent describes what it wants ("map out our Q3 launch"), and the thoughts land on a real, shared canvas your team can watch and keep working in.

How keys stay safe

Scoped to one org. Every key belongs to exactly one organisation and can only read or write that org's data — never another's.
Shown once, stored hashed. We keep only a one-way hash of your key; the raw value lives only where you saved it.
Revoke instantly. Turning a key off cuts its access immediately, even mid-request.
Honest attribution. A key's edits appear in your member list under the name you gave it, so it's always clear what an agent did.

Point an agent at your board

Create a key in the app and make your first call in under a minute.

Get your API key Back to quickstart