Sheetrender MCP

@sheetrender/mcp

MCP server for SheetRender: turn rows of a spreadsheet into one PDF each, such as certificates, letters, donation receipts and offer letters.

The quickest start needs no account and no install. Add the hosted server `https://mcp.sheetrender.com/mcp` as a connector in ChatGPT, Claude or any client that takes a Streamable HTTP URL, then paste or describe your rows. It fills SheetRender's built-in templates and returns a preview and a PDF per row (details).

With a SheetRender API key you get the full tool set: your own saved templates, HTML templates, datasets and batch jobs, either through the npm package below or the same hosted URL.

Setup

Get an API key from sheetrender.com under Settings → API keys, then add this to your MCP client config:

{

"mcpServers": { "sheetrender": { "command": "npx", "args": ["-y", "@sheetrender/mcp"], "env": { "SHEETRENDER_API_KEY": "sr_live_..." } } } }

SHEETRENDER_API_URL is also read, and defaults to https://sheetrender.com. Set it only if you're pointing at a self-hosted or staging instance.

Hosted endpoint

The same server runs at `https://mcp.sheetrender.com/mcp` over Streamable HTTP, so clients that can't spawn a local process can use it too. Nothing is installed; each request carries your API key:

Authorization: Bearer sr_live_...

Requests without that header get the smaller no-key tool set described below. The key goes straight through to the SheetRender API for that one request and is never stored — the server keeps no sessions, so every request stands alone.

Where the key goes depends on the client:

• Claude Code: claude mcp add --transport http sheetrender https://mcp.sheetrender.com/mcp --header "Authorization: Bearer sr_live_..."
• Cursor, Windsurf, VS Code and other clients with an mcp.json:

  {

"mcpServers": { "sheetrender": { "url": "https://mcp.sheetrender.com/mcp", "headers": { "Authorization": "Bearer sr_live_..." } } } }

• Claude API (the Messages API's MCP connector): add {"type": "url", "url": "https://mcp.sheetrender.com/mcp", "name": "sheetrender", "authorization_token": "sr_live_..."} to mcp_servers.
• claude.ai, Claude Desktop and ChatGPT custom connectors take a server URL and an OAuth client, not a static header. Until the endpoint speaks OAuth, use the stdio package above there — it's the same tools, with the key in env — or bridge with npx mcp-remote https://mcp.sheetrender.com/mcp --header "Authorization: Bearer sr_live_..." as the command.

Two differences from the stdio server follow from the process not running on your machine. Rendered PDFs come back inline as a base64 resource (up to 8 MB; larger ones are reported with their size and left for the web app) instead of as a temp-file path, and upload_dataset is not offered because there is no local file to read — send rows with create_dataset instead.

GET /healthz answers 200 without credentials. Request bodies are capped at 25 MB; anything larger is a 413.

A key that merely starts with sr_ proves nothing, so the server waits for the SheetRender API to accept it. Until a call made with the key has succeeded (normally the first tool call, e.g. list_templates), its requests get the same bounds as requests without a key, described below: bodies up to 2 MB, at most 4 JSON-RPC messages per batch, and every message counted toward the per-network budgets. Once the API has accepted the key, the server remembers a hash of it (never the key) for an hour after its latest successful call, and its requests get the 25 MB body cap and batches of up to 20 messages. MCP clients send one message per request, so the batch caps only matter to hand-written clients. If the very first call is a body over 2 MB (a large create_dataset), it gets a 413 that says to make a small call first and retry. Every request, with a key or without, counts toward the server-wide in-flight cap.

One tool call's arguments may hold at most 600,000 values (array elements and object fields together) from an accepted key, enough for create_dataset's 500,000 cells, and 20,000 from a key not yet accepted. Anonymous calls are capped at a little over the largest real call.

Bodies over 2 MB also take one of a few server-wide large-body slots, 1 by default (LARGE_BODY_MAX_IN_FLIGHT). A slot is taken before reading when Content-Length declares such a body, or as soon as a streamed body passes 2 MB, and is held until the response ends. When all are taken, the request gets a 503 with Retry-After: 5 and the rest of its body is not read. One 25 MB body can take around 100 MB of heap while it is decoded, parsed and passed on, so raise this only with the heap (the hosted container runs a 192 MB heap).

Without a key (ChatGPT and Claude directory listings)

When the server runs with SHEETRENDER_DEMO_API_KEY set, a request that sends no Authorization header gets a different, smaller tool set instead of a 401. These tools fill SheetRender's built-in templates (certificate of completion, letter, donation receipt, job offer letter) from rows in the chat, through a dedicated rendering account:

• list_document_templates: the templates, their fields (key, label, required, example, character and line limits).
• render_documents: up to 25 rows per call, one PDF per row; returns a PNG preview and a PDF link per document (both expire after an hour), the rows that missed a required field, and how many of the month's 50 documents per user (in Claude, per conversation) remain. When a limit shared with other users is what cut or refused the call, it says the limit is shared instead of showing a count. A refused or cut call also says the rows can be taken to the website with a continue link. A value over its field's character or line limit is refused before the API is called, and the API's own reason for refusing rows (row number, field and rule, never the value) is passed on.
• create_continue_link: up to 100 rows, stored for 7 days, and a link to the template's page on the website with those rows loaded. Called only when the user wants to continue there.

render_documents comes with an MCP Apps view, ui://sheetrender/documents.html (text/html;profile=mcp-app): a strip of previews with PDF links and a "Continue in SheetRender with these rows" button. Its script, src/widget/documents.ts, is bundled by esbuild into dist/widget/documents.js during deno task build and inlined into the page when the resource is read.

Calls are counted per user: ChatGPT's anonymised openai/subject, else the client IP. Any caller can send openai/subject, so it is believed only from OpenAI's published egress ranges (chatgpt-connectors.json, overridable with OPENAI_EGRESS_CIDRS); from anywhere else the call is counted by IP. The hosted server fetches that list at startup and every 24 hours, keeping the built-in copy (then the last good fetch) whenever a fetch fails or returns anything malformed or empty; it logs one line per refresh. It also logs, at most once an hour, how many calls sent an openai/subject from outside the list, so a stale list shows up.

The server allows 30 render or continue calls per subject or IP per hour (ANON_CALLS_PER_HOUR). Callers counted by IP also share a second bucket per IPv4 /24 or IPv6 /48, 300 calls an hour (ANON_NETWORK_CALLS_PER_HOUR), so a block of cheap addresses counts as one caller. All traffic from Claude's 160.79.104.0/21 network (Anthropic's published outbound range, which the Claude API's MCP connector also uses) shares a separate 3,000-call hourly bucket (CLAUDE_CALLS_PER_HOUR); each Claude conversation that sends its Mcp-Session-Id also gets the 30-call per-subject bucket inside it. Neither User-Agent text nor _meta can claim or leave these buckets. The SheetRender API still applies the monthly document volume against the hashed subject or IP. The subject and IP are sent to the API only as SHA-256 hashes, and the request log carries a fingerprint, the detected client (chatgpt, claude or other) and the row count, never the rows.

Anonymous HTTP bodies are capped at 2 MB, enough for 25 rows at every field's limit; a continue link's rows are capped at 256 KB. A private socket peer is treated as a proxy and only the final valid IP in X-Forwarded-For is trusted. Keep this listener behind Caddy, with no publicly exposed container port, as in the deployment's Compose topology.

Anonymous requests have three more bounds, so a small request cannot make the server generate a lot of output. A JSON-RPC batch may carry at most 4 messages (MCP dropped batching in protocol version 2025-06-18, and ChatGPT and Claude send one message per request); a larger one gets a 400 before anything in it runs. Messages other than tool calls (initialize, tools/list, resources/read, ...) count 600 an hour per IPv4 /24 or IPv6 /48 (ANON_RPC_PER_HOUR); traffic from OpenAI's and Claude's egress ranges is not counted there, since each of those addresses carries many users. And at most 64 requests, with a key or without, are answered at once (ANON_MAX_IN_FLIGHT), 8 per network outside those ranges (ANON_NETWORK_MAX_IN_FLIGHT); past either, the answer is a 503 or 429 with Retry-After: 5. Requests with an API key the SheetRender API has not yet accepted get all three bounds, with tool calls counted toward the 600 as well; once the key is accepted they count only toward the overall in-flight cap, and their batches may carry 20 messages.

A request carrying a SheetRender bearer key uses the API-key tools above. A malformed Authorization header is rejected. The stdio server never offers the anonymous tools.

Running it yourself

sheetrender-mcp-http is a second bin in the package. It reads PORT (default 8080), HOST (default 0.0.0.0), SHEETRENDER_API_URL, MAX_BODY_BYTES and IDLE_TIMEOUT_MS (default 60000), and logs one JSON line per request to stdout — method, path, status, duration, the JSON-RPC method and tool name, a fingerprint of the key (never the key), and key_verified, whether the API had accepted that key yet.

For the anonymous tools, and the request bounds above (which also apply to keyed requests when no demo key is set), it also reads:

| ANON_NETWORK_MAX_IN_FLIGHT | Anonymous requests, and requests with a key the API has not yet accepted, answered at once per IPv4 /24 or IPv6 /48, outside the OpenAI and Cl