Use Doozy from your AI tool

AI tools such as Claude, ChatGPT, and Cursor can work in your Doozy workspace: read and add todos, check on your agents, and look up captures (your recorded meetings and notes). They connect through MCP (Model Context Protocol), the standard way AI apps plug into other services. Doozy hosts the MCP server, so there is no Doozy software to install. Add this server URL to your AI tool:


https://api.usedoozy.com/mcp

You need a Doozy account. Sign up free if you don’t have one. When you connect, your AI tool opens a Doozy sign-in page. You sign in, choose the workspace it may use (the team space that holds your todos; most people have one), and approve. The approval page lists what the AI tool may do, all ticked. Most AI tools ask for everything, including reading meeting transcripts, and you can untick anything you don’t want to grant; see scopes. This sign-in is called OAuth, and it is the default for every AI tool below. For scripts, CI, or a tool that cannot sign in, you can use an API key instead.

Add to Claude Add to Cursor Install in VS Code

Quick setup for coding agents


npx add-mcp https://api.usedoozy.com/mcp -g -n doozy

add-mcp is an open-source installer. It asks which of your installed coding agents to set up, such as Claude Code, Codex, Cursor, VS Code, Gemini CLI, Windsurf, or Zed, and writes the Doozy server into each one’s config. Then sign in to Doozy from each agent, as its section below describes, for example /mcp in Claude Code. -g installs for every project, and -n doozy names the server. add-mcp needs Node.js, and it cannot set up claude.ai or ChatGPT, because those keep their connectors in your online account. Use the sections below for those.

Claude (claude.ai, Claude Desktop, and mobile)

On a Claude Team or Enterprise plan, an Owner adds Doozy for the organization first, under Organization settings > Connectors or with the organization admin link . Members then find Doozy under Customize > Connectors and click Connect, starting at step 3. On Free, Pro, and Max plans, start here:

Open Add Doozy to Claude . If you are signed out, sign in to Claude first.
Check that the URL is https://api.usedoozy.com/mcp, then click Add.
Click Connect. Sign in to Doozy (or sign up free), pick a workspace, and approve.
In a chat, open + > Connectors and turn on Doozy. Then check that it works.

To add it by hand, go to Customize > Connectors > + > Add custom connector and paste the server URL. Leave the advanced OAuth fields empty.

A connector you add works in claude.ai, Claude Desktop, and the Claude mobile apps. The free Claude plan allows one custom connector, so remove another custom connector first if you already have one.

Claude connects from Anthropic’s servers, not from your computer, and its connectors cannot send an API key. Use OAuth here.

Claude Code


claude mcp add --transport http --scope user doozy https://api.usedoozy.com/mcp

Run this in your terminal, then start Claude Code (or restart it if it was open). Inside Claude Code, run /mcp, choose doozy, and choose Authenticate. Your browser opens the Doozy sign-in page, where you can also sign up. --scope user makes Doozy available in all your projects. Leave it out to add Doozy only for the current project, just for you.

ChatGPT

ChatGPT has no install link. Its developer mode adds custom MCP servers. Developer mode needs ChatGPT Plus, Pro, Business, Enterprise, or Edu, and you set it up on chatgpt.com in a browser. A workspace admin can turn it off.

In ChatGPT settings, open Security and login and turn on Developer mode.
Open chatgpt.com/plugins and click +.
Name it Doozy. Set the MCP server URL to https://api.usedoozy.com/mcp and authentication to OAuth. Click Create.
Sign in to Doozy (or sign up free), pick a workspace, and approve.
In a chat, open + > Developer mode and select Doozy.

ChatGPT asks you to confirm before it runs a Doozy tool that changes something.

Codex

This covers the Codex CLI, the Codex IDE extension, and Codex in the ChatGPT desktop app, which share one config.


codex mcp add doozy --url https://api.usedoozy.com/mcp

Codex opens your browser to the Doozy sign-in page. To sign in again later, run codex mcp login doozy. The same server in ~/.codex/config.toml:


[mcp_servers.doozy]
url = "https://api.usedoozy.com/mcp"

Cursor

With Cursor installed, click Add to Cursor at the top of this page, or open the Cursor install link . Cursor opens and asks you to confirm. Then open Cursor Settings, go to the MCP section, click Needs login next to doozy, and sign in to Doozy (or sign up). Ask about your todos in the Agent chat, which is where Cursor uses MCP tools.

To add it by hand, put this in ~/.cursor/mcp.json for every project, or .cursor/mcp.json for one. If the file already lists other servers, add the doozy entry inside the existing mcpServers rather than replacing the file. The same goes for every config snippet on this page.


{
  "mcpServers": {
    "doozy": { "url": "https://api.usedoozy.com/mcp" }
  }
}

You can also use an API key in Cursor.

VS Code (GitHub Copilot)

Install in VS Code · Install in VS Code Insiders

Or run MCP: Add Server from the command palette, choose HTTP, and enter the server URL. To share it with a project, add .vscode/mcp.json. VS Code uses a servers key here, not mcpServers:


{
  "servers": {
    "doozy": { "type": "http", "url": "https://api.usedoozy.com/mcp" }
  }
}

When VS Code asks to sign in to Doozy, click Allow. If the browser sign-in does not return to VS Code, cancel, and when VS Code offers another way, choose the URL handler.

Gemini CLI


gemini mcp add --transport http --scope user doozy https://api.usedoozy.com/mcp

Then, inside Gemini CLI, run /mcp auth doozy and sign in to Doozy in your browser. To use an API key instead, add -H "Authorization: Bearer doozy_sk_..." before doozy.

Windsurf

Add this to Windsurf’s mcp_config.json. Windsurf uses serverUrl, not url:


{
  "mcpServers": {
    "doozy": { "serverUrl": "https://api.usedoozy.com/mcp" }
  }
}

Zed

Add this to Zed’s settings.json, or use Settings > AI > MCP Servers > Add Remote Server. Zed runs the Doozy sign-in when you first use the server:


{
  "context_servers": {
    "doozy": { "url": "https://api.usedoozy.com/mcp" }
  }
}

Other clients

Any MCP client that supports Streamable HTTP and OAuth can use https://api.usedoozy.com/mcp directly. A client that can only start local programs can reach Doozy through mcp-remote , which needs Node.js and runs the Doozy sign-in for it:


{
  "mcpServers": {
    "doozy": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.usedoozy.com/mcp"]
    }
  }
}

Check that it works

Ask your AI tool: “List my active Doozy todos.” It should list the active todos in the workspace you picked, or say there are none.

More things to try:

“What’s on my Doozy list for this week, and what’s overdue?”
“Add three todos from these notes to my Doozy Launch list.”
“Find my latest capture from the design review and summarize the decisions.”
“Assign the ‘draft the release notes’ todo to my writer agent and run it.”
“Show me what my agents did today and which chats are still running.”

When your AI tool connects over OAuth, Doozy shows a consent page. It shows:

Who is asking. For example, “published by claude.ai”. An app that registered itself, or whose identity Doozy couldn’t check, is labelled Unverified app. Only approve an app you just started connecting. Apps on your computer, such as Claude Code, Cursor, and VS Code, often show Unverified app or a warning that Doozy can’t identify the local app. That is expected when you started the connection yourself a moment ago.
Where you go next. A website, or an app on your computer such as Claude Code, which Doozy can’t identify for certain and says so.
Which workspace to use. One connection opens exactly one workspace. To use two workspaces, connect twice.
The scopes the app asked for, each with a checkbox.

Scopes decide what the connection may do:

Scope	Lets the AI tool
`todos:read`	Read todos and todo lists.
`todos:write`	Create, change, complete, archive, and run todos; manage lists.
`chats:read`	Read chats with agents and every message in them.
`chats:write`	Start chats, send messages, and stop a running chat.
`agents:read`	Read agents, their instructions, and their skills.
`agents:write`	Create and change agents and skills.
`captures:read`	Read captures in full, including meeting transcripts.
`captures:write`	Change capture titles, tags, and notes.

Most AI tools ask for every scope, and every requested scope starts ticked. Untick any you don’t want to grant, such as captures:read to keep meeting transcripts out. Scopes covers each one in full.

Your AI tool sees every Doozy action, called a tool in MCP, even ones the connection has no scope for. Using one without its scope returns an error that names the missing scope and says to reconnect and approve it.

To disconnect an app, open Settings > API keys in Doozy. Under Connected apps, click Revoke. The app stops working on its next request and must ask you to approve again. Signing out inside the AI tool, such as codex mcp logout, may only forget the sign-in on your machine, so revoke in Doozy to be sure.

Use an API key instead

Use a workspace API key for scripts, CI, shared machines, or a tool that cannot run OAuth. Create one in Settings > API keys, and choose only the scopes the tool needs. After you create a key, Doozy shows install buttons and commands with the key already filled in. Keys can be set to expire when you create them. Anyone holding a key can use it, so store it like a password. Authentication and keys covers rotation and revocation.

Send the key as a header:


Authorization: Bearer doozy_sk_...

Examples:


# Claude Code
claude mcp add --transport http --scope user doozy https://api.usedoozy.com/mcp \
  --header "Authorization: Bearer doozy_sk_..."
 
# Codex reads the key from an environment variable
export DOOZY_API_KEY="doozy_sk_..."
codex mcp add doozy --url https://api.usedoozy.com/mcp --bearer-token-env-var DOOZY_API_KEY

For Cursor and other clients that read mcp.json:


{
  "mcpServers": {
    "doozy": {
      "url": "https://api.usedoozy.com/mcp",
      "headers": { "Authorization": "Bearer doozy_sk_..." }
    }
  }
}

To check a key from a terminal:


curl https://api.usedoozy.com/mcp \
  -X POST \
  -H "Authorization: Bearer doozy_sk_..." \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  --data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

The response lists the tools under result.tools.

Tools

This table is generated from the server’s own tool definitions. Behaviour shows the hints your AI tool reads before calling a tool. Many AI tools ask you before calling anything that isn’t read-only.

read-only: changes nothing.
writes: changes something in your workspace.
open-world: can start a Doozy agent, which may act in the apps your workspace has connected.
destructive: can replace text, such as an agent’s instructions or a capture’s notes, with no copy of the old version kept.
idempotent: calling it twice with the same arguments has the same effect as calling it once.

Tool	What it does	Scopes	Behaviour
`list_todos`	List workspace todos. Pass todoListName when you know the list by name. Every response includes counts for the filters passed and separately labelled totals for the whole workspace. A reply holds as many todos as fit, which can be fewer than limit; when todos.hasMore is true, pass todos.nextCursor as cursor for the rest.	`todos:read`	read-only
`count_todos`	Count todos without listing them. Returns total, active, byStatus, byPriority, and minutesSaved for the filters passed. Pass todoListName when you know the list by name.	`todos:read`	read-only
`get_todo`	Get a todo with its chat id and latest run status. Pass messagesSince to include new messages from that run chat.	`todos:read`, `chats:read`	read-only
`create_todo`	Create work with an outcome. Use assignees for workspace members or agents. Pass run: true with an agent assignee to start it in one call.	`todos:write`	writes, open-world
`batch_create_todos`	Create up to 50 todos in one call. Use this when the user gives several tasks at once.	`todos:write`	writes, open-world
`update_todo`	Update fields on an existing todo.	`todos:write`	writes, open-world
`complete_todo`	Mark a todo complete.	`todos:write`	writes, idempotent
`reopen_todo`	Reopen a completed todo.	`todos:write`	writes, idempotent
`archive_todo`	Archive a todo without erasing it. Returns the todo after archiving, with isArchived true. It can be restored with unarchive_todo.	`todos:write`	writes, idempotent
`unarchive_todo`	Return an archived todo to the active list.	`todos:write`	writes, idempotent
`run_todo`	Hand a todo to an agent. When agentId is absent, the workspace default Doozy agent runs it. Returns the run id and chat id.	`todos:write`	writes, open-world
`list_chats`	List conversations with agents in this workspace.	`chats:read`	read-only
`get_chat`	Read a chat and its messages. Pass afterSequence or cursor to poll cheaply for only new messages.	`chats:read`	read-only
`create_chat`	Start a conversation with an agent and a first message. A chat is a conversation; a todo is work with an outcome.	`chats:write`	writes, open-world
`send_chat_message`	Send a follow-up message into an existing chat.	`chats:write`	writes, open-world
`stop_chat`	Stop a chat that is taking too long or is no longer useful. Work already done stays in the chat.	`chats:write`	writes, idempotent
`list_agents`	List agents in this workspace.	`agents:read`	read-only
`get_agent`	Get an agent with its instructions, runtime model selection, and skills inline.	`agents:read`	read-only
`create_agent`	Create an agent in this workspace.	`agents:write`	writes
`update_agent`	Update an agent. Omitted fields and null mean unchanged; use clear to empty a field and expectedVersion to reject a stale write. Cleared or replaced text cannot be recovered. Archive or restore with archived in its own request.	`agents:write`	writes, destructive
`preview_agent_update`	Preview a redacted field-level configuration diff without saving it.	`agents:write`	read-only
`list_skills`	List skills for one agent or across the workspace.	`agents:read`	read-only
`get_skill`	Get one skill with its full instructions.	`agents:read`	read-only
`create_skill`	Teach an agent a new named skill.	`agents:write`	writes
`update_skill`	Update a skill. Omitted fields and null mean unchanged; use clear to empty instructions. Cleared or replaced instructions cannot be recovered. This can archive or restore it with the archived field.	`agents:write`	writes, destructive
`list_todo_lists`	List the todo lists in this workspace.	`todos:read`	read-only
`upsert_todo_list`	Create a todo list when id is absent, or update it when id is present. Set archived to manage its archive state.	`todos:write`	writes
`list_captures`	List workspace captures. Tags are included on every capture response. A reply holds as many captures as fit, which can be fewer than limit; when hasMore is true, pass nextCursor as cursor for the rest.	`captures:read`	read-only
`get_capture`	Get a capture with its transcript, notes, content, and tags. Long text comes in parts: when the reply has a continuation, pass its field and nextOffset as field and offset to read the next part.	`captures:read`	read-only
`update_capture`	Update a capture title, tags, or notes. Replacing tags is how a tag is applied. Replaced notes cannot be recovered.	`captures:write`	writes, destructive
`start_capture`	Return the link to the recorder for this workspace. Open it to record. This tool returns a link; it does not record from the terminal.	none	read-only

What tools return

Every todo, todo list, capture, chat, run, agent, and skill in a result has a url that opens it in Doozy.
Read tools that return records also send structuredContent that matches their outputSchema. The text block carries the same JSON for clients that read text only.
Lists return one page at a time. Pass nextCursor back as cursor. A page holds 25 items unless you pass limit, which goes up to 100.
Long text is kept to about 8,000 estimated tokens per reply, counting four ASCII characters as one token and every other character as a whole token, so Chinese, Japanese, and Korean text fits too. The rest of the reply comes on top. Nothing is lost: the reply says how to read the rest. This applies to:
- get_capture, where the transcript, notes, and content share the budget. Cut text is listed under continuation. Call get_capture again with an entry’s field, and its nextOffset as offset, to read the next part.
- get_chat and get_todo messages, which stop early and continue from messages.nextCursor (get_chat) or messagesSince (get_todo), as the reply’s notice says.
- get_agent, which shows as many skills as fit and gives a skillsNextCursor for list_skills.
- The pages of list_agents, list_skills, and list_todo_lists, which also stop early when items are long. A page always keeps at least one item, however long.

What is not supported

Permanent deletes. Archiving a todo, list, agent, or skill is the most any tool does, and everything archived can be restored. Tools marked destructive do replace text with no old copy kept.
Recording. start_capture returns a link to the capture page. It does not record audio from your AI tool.
More than one workspace per connection. Connect again to use another workspace.
API keys in Claude connectors. claude.ai, Claude Desktop, and Claude mobile use OAuth only.
A local server. Doozy is remote only. There is no package to install, and nothing to run on your machine.
Old SSE transport. The server speaks Streamable HTTP. A URL ending in /sse will not work.

Troubleshooting

Claude says it couldn’t reach the server

Check that the URL is exactly https://api.usedoozy.com/mcp. Claude connects from Anthropic’s servers, so a company firewall or VPN on your side does not affect it. To retry, remove the connector and add it again. Claude does not let you edit a connector’s sign-in settings after adding it.

Run the client’s sign-in again: /mcp in Claude Code, codex mcp login doozy in Codex, or Needs login in Cursor. For clients that go through mcp-remote, delete its saved sign-in with rm -rf ~/.mcp-auth and reconnect.

After signing in, I landed in Doozy instead of the approval page

Go back to your AI tool and start the connection again. You are now signed in, so the approval page opens directly.

It worked, then stopped

The app may have been revoked under Settings > API keys > Connected apps, or you may have lost access to the workspace. Connect again. With an API key, check that the key has not been revoked or expired.

A tool says a scope is missing

The scope was unticked when you approved the app, the app didn’t ask for it, or its API key was created without it. Revoke the app under Connected apps and connect again, leaving the scope ticked, or create an API key that holds it.

Doozy tools do not appear

Restart the AI tool or refresh the connector. In Claude, make sure Doozy is turned on for the chat under + > Connectors. In ChatGPT, select it under + > Developer mode. In Cursor, use the Agent chat and check that doozy is enabled in the MCP settings.

My company blocks it

Ask your IT team to allow https://api.usedoozy.com/mcp. Cursor’s enterprise allowlist, VS Code’s chat.mcp.access policy, Windsurf team allowlists, and ChatGPT workspace settings can all block custom MCP servers.

Privacy

An AI tool you connect sees the Doozy data its tools return, within the workspace and scopes you approved. What happens to that data afterwards is up to the tool’s provider and their privacy policy. Doozy’s privacy policy covers Doozy’s side.