Drive a virtual data room from Claude Desktop: install, configure, prompt the MCP server

Read full docsConnect your agent to a data room: full MCP docs

April 10, 2026·9 min read·By dataroom.dev

Claude Desktop speaks the Model Context Protocol natively, which means connecting it to external tools is a configuration exercise rather than an integration project. The Papermark MCP server ships 43 tools that map 1:1 to the REST API. The setup is three lines of JSON and one restart.

This article walks through the connection end-to-end, with the example prompts that actually do useful work once you're connected, the scoping rules that keep an agent's blast radius bounded, and the half-dozen things that go wrong on first setup. The pattern generalizes to any MCP host (Claude Code, Cursor, Zed, Windsurf), but Claude Desktop is the most-used host as of 2026 with roughly 4 million monthly active users by industry estimate.

Why this matters

Without MCP, giving Claude (or any AI agent) the ability to operate a data room requires writing a tool layer yourself: defining JSON schemas for each operation, plumbing OAuth or token auth, building error handling, dealing with rate limits. Conservatively, that's 80-160 engineering-hours for a tool layer matching the breadth of what a hosted MCP server provides, and it goes stale the first time the underlying API ships a new endpoint.

With MCP, Claude Desktop gets the 43 tools for free, the agent operates with the scopes your token grants, makes real authenticated API calls (no mocks, no sandbox confusion), and you see every action in the conversation log. The activation cost is roughly 5 minutes of setup. The economics aren't comparable.

This is also why MCP is rapidly becoming a baseline expectation for B2B SaaS products. Stripe shipped an MCP server in 2025. Linear has one. So do Notion, Sentry, Slack, and an exponentially growing list. The product category of "tools that an agent can natively operate" is partitioning into MCP-equipped and MCP-absent. A data room without MCP is a data room you can't drive autonomously.

Prerequisites

Five things to have ready before starting:

Claude Desktop (current build) for macOS or Windows. Linux support is community-maintained as of writing. Download from claude.ai.
A Papermark API token from app.papermark.com/settings/tokens. Pick the scopes you want the agent to have. Start narrow. Token format is pm_live_….
Node.js 18+ on the same machine. npx runs the server, and Node 18+ ships an embedded fetch. Check with node --version.
About 5 minutes of patience for the initial setup. First npx invocation downloads the MCP server package (~3 MB) which takes a few seconds.
A test dataroom, even an empty one. Useful for verifying the connection works.

Step 1: install the MCP server (sort of)

You don't actually install it permanently. npx fetches and runs the latest version each time Claude Desktop spawns the process, then unloads when the conversation closes. The config file in step 2 is what makes that happen.

If you want to pre-warm the npm cache so the first conversation doesn't have a small startup delay:

npx -y @papermark/mcp-server --version

Expect output like @papermark/mcp-server v0.1.5. If you get npx: command not found, install Node.js. If you get a permission error, your npm cache is in a weird place, npm config get cache to diagnose.

Step 2: edit the config file

The Claude Desktop config file location varies by OS:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux (community build): ~/.config/Claude/claude_desktop_config.json

Open it in your editor of choice:

# macOS
open -a "TextEdit" ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Or with VS Code
code ~/Library/Application\ Support/Claude/claude_desktop_config.json

If the file doesn't exist, create it. Add the Papermark MCP server entry:

{
  "mcpServers": {
    "papermark": {
      "command": "npx",
      "args": ["-y", "@papermark/mcp-server"],
      "env": {
        "PAPERMARK_TOKEN": "pm_live_REPLACE_WITH_YOUR_TOKEN"
      }
    }
  }
}

If you already have other MCP servers configured (filesystem, github, slack, etc.), add papermark as a sibling entry. Don't replace the existing block. The complete shape:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_…" }
    },
    "papermark": {
      "command": "npx",
      "args": ["-y", "@papermark/mcp-server"],
      "env": { "PAPERMARK_TOKEN": "pm_live_…" }
    }
  }
}

Save the file and fully quit Claude Desktop (⌘Q on macOS, File → Exit on Windows. Not just closing the window). Reopen.

Step 3: verify the connection

After reopening Claude Desktop, look for the MCP indicator in the bottom-right of the prompt input area (a small hammer-and-screwdriver icon). Click it; you should see "papermark" listed with 43 tools available.

If it's missing or shows an error, the diagnostic checklist:

Check the config file is valid JSON. Extra trailing commas, missing quotes, and incorrect bracket nesting are the usual culprits. jq . claude_desktop_config.json validates and pretty-prints.
Check the token is correct. Copy it to a terminal and run curl https://api.papermark.com/v1/me -H "Authorization: Bearer $TOKEN". If that returns 200, the token works.
Check Node is on the PATH. Claude Desktop spawns npx directly; if your shell's PATH includes Node but the GUI app's doesn't, you'll get "command not found." Move Node to a system path like /usr/local/bin or set command to the absolute path.
Check the Claude Desktop logs. macOS: ~/Library/Logs/Claude/mcp*.log. Each MCP server gets its own log file with the spawn errors.
Restart Claude Desktop fully. Just closing the window isn't enough. The main process keeps running and only reads the config on cold start.

Step 4: first useful prompt

With the connection live, try this:

List my datarooms and tell me which one has had the most views in the last 30 days.

Claude will call list_datarooms, then get_dataroom_analytics for each, then synthesize the answer. You'll see the tool calls inline in the conversation. Claude shows you exactly which API operation it invoked and what came back.

For your first 5 minutes, try variations:

"What's in my Series A dataroom?"
"How many people opened the Acme deck this week?"
"Create a test dataroom called 'sandbox' and tell me when you're done."
"Find any dataroom that hasn't been viewed in the last 60 days."
"Show me the top 3 most-viewed documents across all my datarooms."

Each takes 5-15 seconds and exercises a different combination of tools. The point of the first session is to confirm the agent can read your data confidently before you trust it with writes.

Worked example prompts

The five patterns that come up most often in practice, with the underlying tool sequences shown:

1: provisioning a deal room

Create a new dataroom called "Project Sandpiper". Upload every PDF from ~/Documents/sandpiper-dd into it. Create three folders inside the dataroom: Financials, Legal, and IP. Move the financial PDFs into Financials, the contracts into Legal, and the patents into IP. When done, give me a password-protected link with expiry in 60 days. Watermark with the recipient name "Greenfield PE · {{timestamp}}".

This prompt exercises create_dataroom, upload_document (×N, typically 10-30), create_dataroom_folder (×3), attach_dataroom_document (×N for the moves), and create_link. The agent does it all in one turn, which on a typical broadband connection takes 30-90 seconds depending on file sizes.

2: engagement triage

For my "Acme Series A" dataroom, list all visitors who viewed the deck in the last 7 days. Sort by total time spent. Flag anyone who returned more than once. Then give me a table of: name, fund, total minutes, return count, last viewed date.

Tool sequence: list_dataroom_documents (to find the deck) → list_visitor_views (filtered by date) → in-context aggregation → markdown table.

3: cleanup audit

Find every link in any of my datarooms that expired more than 90 days ago. Revoke them and give me a summary of what was cleaned up, grouped by dataroom.

Tool sequence: list_datarooms → list_links (per dataroom) → filter by expires_at → delete_link (×N). Smart prompt move: ask the agent to dry-run first ("list them first, don't delete yet, I want to review") and then approve the deletion in a second turn. The agent respects this naturally.

4: recurring distribution

Every Monday at 9am, check my "Board" dataroom, list any director who hasn't opened the latest pack, and post their names to Slack channel #board-ops.

This one requires you to also have the Slack MCP server configured. Claude composes the two: Papermark MCP to read engagement, Slack MCP to post. The scheduling layer is currently Claude-side scheduling or your own cron + Claude API.

5: custom report generation

Generate a Q2 engagement report for all my fundraising datarooms. Include: total unique investors, total dwell time, top 5 investors by engagement, top 5 documents by views, drop-off analysis on the main deck. Format as markdown with embedded tables.

The agent calls list_datarooms (filtered by name pattern), then per-dataroom analytics, then aggregates and formats. For a workspace with 12 datarooms and 80 distinct investors, this takes 60-180 seconds end-to-end.

Scoping safely

The MCP server inherits your token's scopes. Mint a token with the smallest possible scope set for the agent's job. This is the single most important security practice.

For provisioning and sharing workflows, the typical scope set:

datarooms.write
documents.write
folders.write
links.write
analytics.read

For pure analytics and observation workflows where the agent only reads:

datarooms.read
documents.read
links.read
analytics.read
visitors.read

For an agent that should never modify state, regardless of what the user prompts it to do:

datarooms.read
analytics.read
visitors.read

Don't include *.delete scopes unless the workflow specifically requires destructive actions. A Claude agent that can't call delete_dataroom literally cannot accidentally delete a dataroom. The API rejects the call with 403 invalid_scope. That's the model.

Three additional safety practices worth adopting:

One token per agent role. The provisioning agent gets one token; the analytics digest agent gets another. Each token has only the scopes that agent needs.
Rotate tokens quarterly. Mint, deploy, revoke the old. Standard credential hygiene.
Log every tool invocation. The MCP server logs to stderr by default; capture it for forensic review. The same data is also queryable via the Papermark audit log API after the fact.

Common issues

The six most common first-setup problems, ordered by frequency:

"papermark" doesn't appear in the MCP indicator. Almost always invalid JSON in the config file. Run it through jq . claude_desktop_config.json to check. The error message will pinpoint the syntax issue.
"401 Unauthorized" on first call. Token is wrong, revoked, or expired. Regenerate at app.papermark.com/settings/tokens. Tokens are shown once; if you lost the value you have to mint a new one.
"403 Forbidden. Invalid_scope". Token doesn't have the scope the agent tried to use. Either add the scope to a new token (you can't add scopes to an existing token. Mint a new one) or scope the agent's prompt down to operations covered by the existing token.
Tool calls hang. Network issue between the local MCP process and api.papermark.com. Try papermark doctor to diagnose. Corporate VPNs that proxy outbound traffic are a common cause; whitelist api.papermark.com on port 443.
npx fails with permission errors. Your npm cache is in a directory the GUI process can't write to. Set npm config set cache ~/.npm-cache --global and restart.
Tool calls succeed but the agent doesn't use them. Usually means the prompt is ambiguous and the agent decided to answer from context instead of calling the API. Be more specific: "Use the Papermark MCP tools to..." prompts the agent toward tool use.

Cost considerations

The MCP server itself is free (npm package, no metering). The cost components are:

Papermark API calls. Free tier covers personal use (1 team member, 50 documents, 50 links). Paid tiers start at €24/month (Pro) for individual users; team and data-room tiers run €59-€99/month at the time of writing. The API has no per-call metering on any tier, so even a heavily-used agent doesn't generate additional API charges. Verify current pricing on the Papermark pricing page before purchasing.
Anthropic API costs for Claude. When using the agent through Claude Desktop with your own Anthropic account, you pay per-token. A typical multi-step agent prompt costs in the cents-to-low-dollars range depending on context size and number of tool calls. For Claude Pro/Team subscribers, usage is included in the subscription up to plan limits.
Compute for the local MCP process. Negligible. A few hundred MB of RAM, near-zero CPU.