Build on Backrow: The Open API and MCP Server, Explained

Most study and meeting apps trap your data. You record, you transcribe, you take notes — and then it all lives inside one app with no way out. You can't script against it, and an AI agent can't touch it.

backrow is different. It has an open REST API and a remote MCP server, both on the Pro and Max plans. Your own code can build on it, and any MCP-capable AI agent can read and act on your material. This post explains what's actually exposed, how auth and credits work, and how to make your first call.

Two ways to build

There are two front doors to the same capabilities.

• REST API. A standard HTTP API for your own code, scripts, and backends. Bearer-key auth, scope-gated endpoints, and a public OpenAPI 3.1 spec.
• MCP server. A remote Model Context Protocol server so AI agents — Claude Desktop, Cursor, ChatGPT, VS Code, Windsurf, and other MCP hosts — can call backrow's tools directly. Same bearer auth, same scopes, same credits.

Both surface the same underlying capabilities. Pick the REST API when you're writing code; point an MCP host at the server when you want an agent driving.

What you can do with it

The platform exposes backrow's own engine — your data, not third-party data. Verified live:

• Transcription — turn recordings into text.
• Notes — create notes and run AI transformations on them.
• Flashcards — create decks, add cards, and review them on an SM-2 spaced-repetition schedule.
• Knowledge-state — read a structured view of concept mastery, weak areas, and retention risk.
• AI tutor — chat with the tutor over your material.
• STEM engine tools — run specialized math, CS, chemistry, and physics tools.
• Learning paths and quizzes — list and manage paths, submit quizzes.
• Credits and account — read your balance and credit-transaction history.

Note the honest boundary: the API and MCP server expose the documented endpoints and tools, not literally every one of backrow's 120+ in-app tools. A live probe of the MCP server reports its current tool count — at the time of writing, 98 tools. Check the docs for the authoritative endpoint and tool list rather than assuming a feature is exposed.

Auth and access

• Plan: Pro ($44.99) or Max ($89.99). The API and MCP server are a paid-plan feature.
• Keys: Create a bk_live_ API key at backrow.ai/developers. [VERIFY: the launch kit and registry docs reference key creation at both backrow.ai/developers and backrow.ai/platform — confirm the canonical key-management path before linking it in production copy.]
• Auth header: Every request — REST or MCP — uses an HTTP Authorization: Bearer bk_live_... header.
• Scopes: Keys are scope-gated. An MCP tools/list only returns the tools your key's scopes allow, and the scope is re-checked on every call.
• Rate limit: 60 requests per minute per key.

Credits: one balance, priced by the work

This is the part most platforms get wrong, and the part backrow got right. There's one credit balance across the app, the REST API, and the MCP server. The same call costs the same whether a human clicks a button or an agent makes the request. No per-interface markup — you pay for the work, not the transport.

It's also safe by design. Credit-charging operations debit up front, and the balance is a hard cap — you can't spend more than you've got. If you're short, the call returns an insufficient_credits error (the 402 equivalent). If a call fails, the credits are automatically refunded. On the REST API, an opt-in Idempotency-Key header means a retried write never double-charges.

Your first MCP connection

Point any MCP host at the server with a four-line config:

{
  "mcpServers": {
    "backrow": {
      "url": "https://backrow.ai/mcp",
      "headers": {
        "Authorization": "Bearer bk_live_..."
      }
    }
  }
}

Replace bk_live_... with a real key. The server speaks Streamable HTTP at MCP spec revision 2025-06-18. You can sanity-check it before you even add a key:

curl https://backrow.ai/mcp
# -> {"protocol":"mcp","protocolVersion":"2025-06-18","transport":"streamable-http",...,"toolCount":98,...}

That no-auth GET returns the transport, protocol version, and live tool count — handy for a health check.

A first REST call

If you'd rather drive from code than from an agent, the REST API is the same capabilities behind a normal HTTP interface. The shape is the standard bearer-auth pattern:

curl https://backrow.ai/functions/v1/api-v1/... \
  -H "Authorization: Bearer bk_live_..."

The exact paths, request bodies, and responses are defined in the public OpenAPI 3.1 spec, so you don't have to guess. [VERIFY: confirm the canonical base path and the published location of openapi.json — the developer-platform launch kit references the REST API under /functions/v1/api-v1 and a public spec at /openapi.json; verify both before hardcoding them in production docs.] Point your HTTP client or an OpenAPI-aware code generator at the spec and you have a typed client without writing it by hand.

Why an open platform is the point

It's worth being clear about why this matters, because most apps in this space deliberately don't do it. A study or meeting app with no API keeps your data captive — which is convenient for the vendor and a dead end for you. The moment your notes, transcripts, and learning data are reachable by your own code and by an agent, they stop being a feature you rent and start being infrastructure you can build on.

That's the difference between a tool and a platform. A tool does a fixed set of things its makers imagined. A platform lets you compose those things into workflows they didn't. Want your meeting recordings to flow straight into a flashcard deck every morning? Want an agent to check your retention risk and tell you what to review? Want to pipe your knowledge-state into a dashboard? None of that needs backrow to ship a feature for it. It needs an API and an MCP server, which is exactly what's here.

What it does not do

Being honest about the edges matters more than padding the feature list.

• No third-party connectors as a product. The API and MCP server expose backrow's own engine — your recordings, notes, and learning data. They are not a "connect all your tools" hub.
• It never produces or submits graded work. This is a layer for capturing, organizing, and retrieving your own material — not for generating or turning in assignments, and not for evading any kind of detection.
• Webhook event delivery — [VERIFY: the developer-platform launch kit lists HMAC-signed webhooks for four events (path.created/completed, quiz.submitted/mastered) as live; confirm against the current OpenAPI spec at /openapi.json before documenting webhooks publicly, since this batch's source guardrails flag event delivery as not assured.]

Build something

The full reference, the OpenAPI spec, and the MCP details live at backrow.ai/developers. If you've got a Pro or Max plan, you're a key away from scripting your own learning workflow or handing it to an agent.