Quickstart

Keyboard works with any MCP client that supports remote servers. Setup is the same everywhere: add Keyboard's server URL to your client, sign in when it prompts you, see it work against the built-in demo workspace, then connect the apps you want your AI to use.

Keyboard's MCP endpoint:

https://mcp.keyboard.dev/mcp

1. Add Keyboard to your client

claude mcp add --transport http keyboard https://mcp.keyboard.dev/mcp

{
  "mcpServers": {
    "keyboard": {
      "url": "https://mcp.keyboard.dev/mcp"
    }
  }
}

{
  "servers": {
    "keyboard": {
      "type": "http",
      "url": "https://mcp.keyboard.dev/mcp"
    }
  }
}

{
  "mcpServers": {
    "keyboard": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.keyboard.dev/mcp"]
    }
  }
}

2. See it work with no connections

You don't have to authorize a single real app to watch Keyboard run end to end. Every account comes with Keyboard Workspace, a built-in sandboxed docs app that is already connected: no OAuth, nothing to configure. Ask your client:

• "I'm new to Keyboard. Show me what it can do using the demo workspace first: create a sample doc and give me the link so I can open it in my browser. Then, once I've seen it, help me connect my own accounts."

Keyboard plans the task, writes a short script, and runs it in an isolated sandbox, with approval controls so you can review what executes. Open workspace.keyboard.dev (sign in with the same Keyboard account) and the doc the AI just created is sitting there. That's the whole loop (auth, planning, sandboxed execution, a real API call) before you've connected anything you care about.

The demo is recommended, not required. If you'd rather point Keyboard at your own apps right away, skip ahead to step 3 (or just tell your AI client to skip the demo).

3. Connect your apps

Once you've seen the demo work, point Keyboard at your real tools. Keyboard can only reach the apps you've authorized. Connect them at chat.keyboard.dev/connect, or just ask from inside your AI client:

• "Connect my Slack and GitHub accounts to Keyboard."

Keyboard walks you through each app's own OAuth sign-in. Your credentials are stored by Keyboard and injected at execution time. They're never pasted into config files and never visible to the model.

Then try something that touches a connected app:

• "What apps do I have connected through Keyboard?"
• "Send 'hello from Keyboard' to the #general channel in Slack."
• "List my open GitHub pull requests and summarize the oldest one."

Sample app: Keyboard Workspace

The demo workspace you used in step 2 is Keyboard Workspace (workspace.keyboard.dev), a minimal, Google Docs-style document app tied to your Keyboard account. It lets you exercise the entire flow (auth, planning, sandboxed execution, real API calls) without connecting a single production data source.

• Nothing extra to authorize. Workspace signs you in with the same Keyboard account you created in step 1, so "connecting" it grants access to a sandbox, not to any of your real tools.
• Org-scoped and encrypted. Documents are only visible to your organization and their content is encrypted at rest.
• Disposable by design. It's a sandbox, so documents are automatically deleted after 7 days.

Try it

Open workspace.keyboard.dev, sign in with Keyboard, and you have an empty workspace. Then ask your MCP client to work with it:

• "Create a document in my Keyboard Workspace titled 'Meeting notes' with a short agenda for a product sync."
• "List the documents in my Keyboard Workspace and summarize the most recently updated one."
• "Add a 'Decisions' section to the 'Meeting notes' document in my Keyboard Workspace."

Refresh the Workspace page after each task. The changes the AI made show up there, so you can watch the full round trip end to end.

Bring your own apps

Keyboard reaches Workspace the same way it reaches any app you register yourself. If your organization uses a service or internal API that Keyboard doesn't cover out of the box, an admin can register it as a custom OAuth app. Your AI can then work with it exactly as it did with Workspace, and your tokens stay inside Keyboard's secure proxy, never in code, logs, or the model's context.

Troubleshooting

• The connector never asks me to sign in. Remove and re-add it, and make sure you used the full URL including the /mcp path.
• My client can't add remote servers. Use the mcp-remote bridge shown under Other clients above.
• A task fails with a missing-account error. The app isn't connected yet. Visit chat.keyboard.dev/connect and authorize it, then retry.
• My Keyboard Workspace documents disappeared. That's the sandbox's 7-day retention doing its job. Workspace is for trying things out, not for keeping anything you care about.