MCP

Waper exposes MCP (Model Context Protocol) over Streamable HTTP. Your agent client can read briefs, search the library, write documents, create watches, transcribe audio and video, and talk to your own Waper agent.

The easiest way: open Waper → Settings → API & MCP, Create key, then pick your client under "Connect an app" and copy the ready-made config or command — a key you just created is filled in for you.

Endpoint

https://waper.ai/mcp Authorization: Bearer <your API key>

API keys start with wpr_; see API keys. Replace wpr_xxx below with your key.

Client setup

Claude Code

Run in a terminal:

claude mcp add --transport http waper https://waper.ai/mcp --header "Authorization: Bearer wpr_xxx"

Cursor

Add this to ~/.cursor/mcp.json (create it if needed), then restart Cursor:

{
	"mcpServers": {
		"waper": {
			"url": "https://waper.ai/mcp",
			"headers": { "Authorization": "Bearer wpr_xxx" }
		}
	}
}

VS Code

Use the Add to VS Code button in settings, or run:

code --add-mcp '{"name":"waper","type":"http","url":"https://waper.ai/mcp","headers":{"Authorization":"Bearer wpr_xxx"}}'

Claude Desktop

  1. Open Customize → Connectors → + Add → Add custom connector;
  2. Name: waper. URL: https://waper.ai/mcp;
  3. Authentication: No sign-in;
  4. Request headers: choose authorization and enter Bearer wpr_xxx (including Bearer and the space).

Request headers are still rolling out. If you don't see them, use Claude Code or another client for now.

Codex

Add this to ~/.codex/config.toml:

[mcp_servers.waper]
url = "https://waper.ai/mcp"
http_headers = { "Authorization" = "Bearer wpr_xxx" }

ChatGPT

ChatGPT only connects to services that support signing in through it (OAuth); it can't send an API key. Waper doesn't support that sign-in yet — we're working on it. Use one of the clients above in the meantime.

Other MCP clients

Any client that supports Streamable HTTP works: use the endpoint above and send the key in the Authorization header. The server is stateless, accepts POST only and replies with JSON; initialize returns the server info and instructions; read the tool list with tools/list.

Tools

The tools have the same shape as your own Waper agent's in a conversation: two tools to search and read, and everything else in the app waper, used through its guide and one call. The operations are the ones your agent uses, defined once: same arguments, same approval rules, same work record and the same undo. Results are JSON (also returned as structuredContent).

  • search, read: search your own material — documents, library, brief items and audio and video transcripts (in picks some; all by default) — and read one result by its type and id (a document's Markdown, the saved text of a page or file, a brief item with the articles it cites, a transcript);
  • app_tools: Waper's guide. {"app":"waper"} lists its modules and their operations; add "module":"watches" for that module's notes and every operation's arguments, or "tool" for one operation's full parameters;
  • app_run: run one operation, for example {"app":"waper","tool":"create_doc","args":{"title":"Plan","markdown":"# Plan"}}. Wrong arguments come back with the full parameters;
  • ask_agent, read_conversation: send a turn to your main Waper agent (Kiki) and read that call's chat; it can move work that takes a while to the background and do it itself, but never brings in your other agents, and it can't reach your own chats (it knows your watches, library, documents and memory, and can use the apps you connected); pass watchId to ask about one watch, or skill (a slug from list_skills) to have the agent follow one of your skills for that message. ask_agent waits a little: once everything the message set off has a result and the agent has said so, you get the final answer; if it isn't there yet you get the conversation ID instead, and read_conversation shows the agent as still answering until it is. When work stops to wait for your approval, the agent says what it is waiting for and that answer is complete; after you approve, the result comes as a new message in that conversation.

The modules an API key can use (app_tools always gives the current list):

  • knowledge: knowledge bases (called space in arguments) and documents — list_spaces, list_docs, create_doc, edit_doc (read the resource waper://spec/markdown before writing), and start_research, deep research in the background that writes a cited report as a document; also creating, renaming and deleting knowledge bases, folders and documents, moving documents, earlier versions, and linking watches. Deleting a document or a knowledge base puts it in the trash for 30 days: list_trash and restore_trash_item bring it back;
  • images: image_generate draws one image from a description; to change an image instead, pass it in images (a library file fil_… or the task ID tsk_… an earlier call returned; one image for now) and say what to change, and the rest stays. It runs in the background (about half a minute) and returns a task ID: read it with get_task, whose output fileId is the image once it is made (it also goes to your library); choose an optional aspectRatio: 1:1, 3:2, 2:3, 16:9, or 9:16 (for example, 9:16 for a phone wallpaper, 1:1 for an avatar). If omitted, generation is square and editing uses the closest supported ratio to the original. quality defaults to standard; use high only when high quality is explicitly wanted. Fallback services may use their default quality, at the same per-image price; resolution uses the service default;
  • library: save_link saves a page to the library; transcribe_media turns audio and video into transcripts in the background (the same ones you see in Notetaker; read it with read a few minutes later); update_library_item, retry_library_item and delete_library_item change a note or filing, read a page or a failed file again, and move an item to the trash;
  • watches: search_watches, list_watches, latest_brief and get_knowledge find watches (public ones and your own), read the latest brief and a watch's knowledge base (weekly recaps, timeline, entities); create_watch starts a new watch (counts toward your monthly watches; the first brief is written in the background); update_watch changes the scope, name, visibility and addresses of a watch you created (a scope or address change is charged by use and writes a brief for the new scope right away). Wherever an operation takes watchId, a watch's id or its slug both work;
  • skills: list_skills, read_skill — your skills, Waper's built-in ones (including the ones you turned off) and your own, and a skill's instructions and reference files; also hiding or showing a skill and deleting your own;
  • routines: past and upcoming runs of your routines (creating and changing routines is done in Waper or by your agent);
  • settings: read and change your settings (language, time zone, when the daily brief arrives, whether you receive brief emails), list the models you can pick, find your invite link;
  • tasks: list_tasks, cancel_task, retry_task for background work; check_action — what you decided about an action that was waiting for your approval.

Your connected apps (Gmail, Notion …) aren't available over MCP directly: an outside agent asks your agent with ask_agent, which can use them.

Approval and undo

What an outside agent does through MCP follows the same rules as your own agent:

  • A call that comes through MCP has nobody there with you: reading and anything in Waper that can be undone just happen; the rest goes through the auto-review. What the review lets through runs; what it blocks answers {"status":"blocked_by_review",…} and nothing is done (under Rules in settings, "Recently blocked" lets you approve it and try it once);
  • When it needs your decision (sending to other people in your name, a payment, deleting something that can't be restored, a single action estimated at over 600 credits or more than you have left, or the review isn't sure), the tool answers {"status":"waiting_for_user_approval","actionId":"…"} instead of doing it. Nothing has happened yet;
  • Only you can approve, in Waper; the card is in Kiki's chat (for a direct tool call and for one from ask_agent alike); an API key can't approve, set "always allow" rules or trusted recipients, or undo. You get the usual notification;
  • Later the agent can run check_action with the actionId through app_run: executed means you approved it and it was done;
  • Everything done through MCP shows up in your work record and can be undone there within the usual window (documents and library: 7 days). Editing a document is the exception: each edit is kept in the document's version history, and you restore an earlier version there.

Billing and limits

  • ask_agent charges actual model cost in credits (including work it does in the background and the turn in which it tells you the result), transcribe_media charges by duration, start_research charges per report, image_generate charges per image, at the making or the changing price (only when one is made), and create_watch counts toward your monthly watches;
  • Rate limits: see API keys. Each key can start at most 10 actions that spend credits a minute; past that the tool returns a message starting with RATE_LIMITED, and you can call it again a minute later. Tools only touch your own data.