# Carbone MCP (remote · mcp.carbone.io) Generate PDF/DOCX/XLSX/PPTX from templates+JSON. Convert Office/HTML/MD to PDF. Universal templating - Trust score: 66/100 (medium) - Change this week: +3 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-08-03 ## Components - remote · `mcp.carbone.io`: 66/100 (this document), [markdown](https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp.md), [page](https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp) - npm · `carbone-mcp`: 44/100, [markdown](https://verifymcp.io/servers/io-carbone-carbone-mcp/carbone-mcp.md), [page](https://verifymcp.io/servers/io-carbone-carbone-mcp/carbone-mcp) ## Channel facts - Endpoint: `https://mcp.carbone.io` - Transports: `streamable-http` - Auth: `none` - Version: `1.5.0` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-08-03. - **Endpoint Security**: 57/100 - The endpoint's TLS certificate is valid, in date, and uses a strong key. - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (delete_template). - HTTPS is enforced; there's no plaintext access path. - HSTS check failed: the Strict-Transport-Security header is absent. - DNSSEC check failed: this domain isn't protected by DNSSEC. - **Transport & Reachability**: 100/100 - Verified streamable-http transport via a live MCP handshake. - **Schema Quality & AI Usability**: 72/100 - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name). - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 6020 tokens (~401/item across 15 items; 11 tools + 4 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 27/100 - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (45% of tools); any adoption earns full credit. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### Claude ```bash claude mcp add --transport http io-carbone-carbone-mcp https://mcp.carbone.io/ ``` ### Codex ```toml [mcp_servers.io-carbone-carbone-mcp] url = "https://mcp.carbone.io/" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "io-carbone-carbone-mcp": { "type": "remote", "url": "https://mcp.carbone.io/", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add io-carbone-carbone-mcp --url https://mcp.carbone.io/ --transport streamable-http ``` ### Hermes ```yaml mcp_servers: io-carbone-carbone-mcp: url: "https://mcp.carbone.io/" ``` ### Other ```json { "mcpServers": { "io-carbone-carbone-mcp": { "type": "http", "url": "https://mcp.carbone.io/" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-08-02 (score 66, +1) No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-07-31 (score 65, 0) - [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server ### 2026-07-30 (score 65, +1) No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-07-28 (score 64, +1) No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-07-27 (score 63, +1) - [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server ### 2026-07-26 (score 62) First indexed and scored. ## MCP tools (11) ### `list_templates` (~312 tokens) List Templates List stored Carbone templates with filtering, search, and pagination. Filter by Template ID, Version ID, category, or upload origin. Use includeVersions to see the full version history of each template. Supports cursor-based pagination for large collections. Note: filtering by tags is not supported by the Carbone API — use list_tags to discover tags, then filter results manually. Note: templates uploaded with versioning disabled appear with id = null and are identified only by their versionId — pass that versionId where a Template ID is expected (e.g. delete_template, download_template). Input parameters: - `category` (string): Filter by category (e.g. "invoices", "legal"). - `cursor` (string): Pagination cursor from the previous response nextCursor field. Use to fetch the next page. - `id` (string): Filter by Template ID (64-bit format). Cannot be a Version ID. - `includeVersions` (boolean): If true, returns all versions for each template. Default: false (only deployed version). - `limit` (integer): Maximum number of results to return. Must be between 1 and 100 (Carbone API limit). Default: 100. - `origin` (integer): Filter by upload origin. 0 = uploaded via API, 1 = uploaded via Carbone Studio. - `search` (string): Fuzzy search in template names, or exact match on Template ID / Version ID. - `versionId` (string): Filter by Version ID (SHA-256 format). Output parameters: - `hasMore` (boolean): Whether more results are available via the cursor. - `nextCursor` (string): Cursor to pass to the next list_templates call. - `templates` (array): The matching templates (all fields). ### `convert_document` (~1009 tokens) Convert Document Convert any document to another format without storing a template. Supports 100+ input/output format combinations: Office documents, PDFs, images, web pages, spreadsheets, and more. The source file can be a local path, a URL, or a base64 string. Use render_document instead when you need data injection ({d.field} tags), translations, or batch generation. Common conversions: DOCX → PDF (file: "report.docx", convertTo: "pdf"), XLSX → PDF (file: "data.xlsx", convertTo: "pdf"), PPTX → PDF (file: "slides.pptx", convertTo: "pdf", converter: "O" for best fidelity), HTML → PDF (file: "page.html", convertTo: "pdf", converter: "C" for full CSS/JS rendering), DOCX → HTML (file: "doc.docx", convertTo: "html"), XLSX → CSV (file: "sheet.xlsx", convertTo: "csv"), PDF → PNG (file: "doc.pdf", convertTo: "png"), PPTX → PNG (first slide as image), MD → PDF (file: "readme.md", convertTo: "pdf"). Input parameters: - `asAttachment` (boolean): If true, return the document as a downloadable file attachment (a base64 EmbeddedResource), for any format. Default delivery: text and png/jpg/gif/webp are returned inline; other binary outputs (PDF,… - `convertTo` (required): Target output format. Documents : "pdf", "docx", "xlsx", "pptx", "odt", "ods", "odp", "odg", "rtf", "epub". Web/text : "html", "xhtml", "txt", "csv", "md", "xml", "idml". Images : "png", "jpg", "… - `converter` (string): Converter engine. Only relevant when convertTo is "pdf" (or an image format rasterised from a document). "L" — LibreOffice (default): best all-round engine for DOCX, XLSX, PPTX, ODT, ODS, ODP. "O" —… - `egressAuthorization` (string): Value for the Authorization header Carbone adds to its OUTBOUND (egress) requests during conversion — e.g. when a Chromium HTML→PDF conversion fetches a protected external image or stylesheet. For ex… - `file` (string, required): The document to convert. Three input forms are accepted: (1) Local file path — absolute or relative, e.g. "/home/user/report.docx" or "./invoice.xlsx". (2) HTTPS URL — the file is downloaded automati… - `outputPath` (string): Optional local file path to save the converted document to (e.g. "/home/user/out.pdf" or "~/out.pdf"). When set, the file is written to disk and the tool returns the saved path + size instead of embe… - `returnLink` (boolean): If true, generate the document and return a public download URL instead of the file contents. The link is SHORT-LIVED and ONE-TIME — Carbone deletes the file after the first download — so it is meant… ### `render_document` (~2806 tokens) Generate Document Generate a document by merging a Carbone template with JSON data. Two modes: (1) pass templateId to use a previously uploaded template; (2) pass template (file path, URL, or base64) to upload and render in a single request without storing a template. Supports output format conversion, multilingual rendering, currency conversion, batch generation, and advanced PDF options (watermark, password, PDF/A). Async mode: pass webhookUrl to render asynchronously — Carbone will POST the renderId to your URL when the document is ready. Async mode is required when using batch generation (batchSplitBy). Input parameters: - `asAttachment` (boolean): If true, return the document as a downloadable file attachment (a base64 EmbeddedResource), for any format. Default delivery: text and png/jpg/gif/webp are returned inline; other binary outputs (PDF,… - `batchOutput` (string): Container format for the batch result. Use "zip" to receive all generated documents as a single ZIP archive. Must be used together with batchSplitBy. - `batchReportName` (string): Filename pattern for each individual document inside the batch ZIP. Supports Carbone tags. Tags are resolved against the item's data (relative path) or the full dataset (absolute path). Examples: "in… - `batchSplitBy` (string): JSON path to the array in your data that drives batch generation. One document is generated per element of the array; all documents are bundled together. Use batchOutput: "zip" to receive a single ZI… - `complement`: Extra data object accessible in templates with {c.field} tags (as opposed to {d.field} for main data). Useful for static or shared values that should not be mixed into the main dataset: company info,… - `convertTo`: Output format. If omitted, the output matches the template format. Documents : "pdf", "docx", "xlsx", "pptx", "odt", "ods", "odp", "odg", "rtf", "epub". Web/text : "html", "xhtml", "txt", "csv", "md… - `converter` (string): Converter engine. Only relevant when convertTo is "pdf" (or an image rasterised from a document). "L" — LibreOffice (default): best all-round engine for DOCX, XLSX, PPTX, ODT, ODS, ODP. "O" — OnlyOff… - `currencyRates`: Exchange rate table used by :formatC for currency conversion. Keys are ISO 4217 currency codes; values are rates relative to a common base. The base currency should have rate 1. Example: { "EUR": 1,… - `currencySource` (string): ISO 4217 currency code of the monetary amounts in the JSON data. Used by the :formatC formatter as the conversion source. Must be set together with currencyTarget and currencyRates. Example: "EUR" if… - `currencyTarget` (string): ISO 4217 currency code of the output document. The :formatC formatter converts amounts from currencySource to this currency using currencyRates. Must be set together with currencySource and currencyR… - `data`: JSON data merged into the template — an object, or a top-level array (accessed with {d[i].field}). Access fields with {d.fieldName} tags. Nested objects: {d.customer.name}. Array loops: {d.items[i].d… - `egressAuthorization` (string): Value for the Authorization header Carbone adds to its OUTBOUND (egress) requests while rendering — fetching external images ({d.imageUrl}), external PDFs (:appendFile / :attachFile), and calling web… - `enum`: Enumeration map used with the :convEnum(TYPE) formatter to translate code values into human-readable labels. Define one key per enum type; each value is an object mapping code → label. Example: { "ST… - `hardRefresh` (boolean): If true, Carbone recomputes pagination and refreshes the table of contents after rendering. Requires convertTo to be defined. Use this for DOCX/ODT templates that contain a TOC field or cross-referen… - `lang` (string): Locale of the generated document. Affects three things: (1) {t(key)} translation tags — selects the matching translation from the translations map. (2) :formatN number formatter — applies locale-spec… - `outputPath` (string): Optional local file path to save the generated document to (e.g. "/home/user/out.pdf" or "~/out.pdf"). When set, the file is written to disk and the tool returns the saved path + size instead of embe… - `reportName` (string): Filename (WITHOUT extension) for the generated document, returned in the Content-Disposition header. Carbone automatically appends the extension that matches convertTo, so do not include one — passin… - `returnLink` (boolean): If true, generate the document and return a public download URL instead of the file contents. The link is SHORT-LIVED and ONE-TIME — Carbone deletes the file after the first download — so it is meant… - `template` (string): Inline template for one-shot render without storing a template first. Accepts a local file path (e.g. /home/user/invoice.docx), a URL (https://example.com/template.docx), or a base64-encoded string.… - `templateId` (string): The ID of a previously uploaded template to render. Two ID formats are accepted: (1) Template ID (64-bit) — stable identifier shared across versions; Carbone automatically uses the deployed version.… - `timezone` (string): IANA timezone used to convert dates in the rendered document. Default: "Europe/Paris". Applied when templates use the :formatD formatter, e.g. {d.date:formatD(YYYY-MM-DD HH:mm)}. Common values: "UTC"… - `translations`: Translation map for multilingual documents. Requires "lang" to be set to select the active locale. Top-level keys are BCP-47 locale codes; values are key → translated-string maps. Template usage: {t(… - `variableStr` (string): Carbone alias expressions evaluated once before rendering, available everywhere in the template. Used to pre-compute reusable values or shorten repetitive paths. Syntax: "{#aliasName = expression}".… - `webhookHeaders` (object): Custom headers Carbone will include when POSTing to your webhookUrl. Pass plain header names as keys — the prefix "carbone-webhook-header-" is added automatically before sending to Carbone, and Carbo… - `webhookUrl` (string): Webhook URL to enable asynchronous rendering. When provided, Carbone returns immediately and POSTs { "success": true, "data": { "renderId": "..." } } to this URL when the document is ready. The defau… ### `list_categories` (~57 tokens) List Categories List all template categories currently in use in your Carbone account. Categories act like folders for organising templates (e.g. "invoices", "legal", "hr"). Use the returned names as the category filter in list_templates or upload_template. Output parameters: - `categories` (array): Template category names in use. ### `list_tags` (~76 tokens) List Tags List all tags currently used across templates in your Carbone account. Tags are free-form labels attached to templates (e.g. "sales", "billing", "v2"). Note: the Carbone API does not support filtering list_templates by tag — use this tool to discover available tags, then call list_templates and filter the results manually. Output parameters: - `tags` (array): Template tag names in use. ### `upload_template` (~535 tokens) Upload Template Upload and store a reusable Carbone template. Once uploaded, use render_document with the returned Template ID to generate documents from it. Supports versioning: multiple versions can live under a single stable Template ID, with deployedAt controlling which version is active. Accepted formats: DOCX, XLSX, PPTX, ODT, ODS, ODP, ODG, HTML, XHTML, IDML, XML, Markdown, PDF, and more. Input parameters: - `category` (string): Group templates into folders/categories (e.g. "invoices", "legal", "hr"). - `comment` (string): Free-text comment to describe the template version or its purpose. - `deployedAt` (integer): UTC Unix timestamp (seconds) to set as the deployment time for this version. Carbone uses the version with the most recent deployedAt when rendering via Template ID. Use 42000000000 to deploy immedia… - `expireAt` (integer): UTC Unix timestamp (seconds) at which this template will be automatically deleted. Use 42000000000 to delete immediately (special "NOW" sentinel value). - `id` (string): Existing Template ID (64-bit format) to add this upload to its version history. If omitted, a new Template ID is generated. Providing a Version ID (SHA-256) is not allowed and will cause an error. - `name` (string, required): Display name for the template (e.g. "Invoice Template", "NDA Contract"). - `sample` (array): Sample input data attached to the template for testing in Carbone Studio. Each item must include data, complement, translations, and enum objects. - `tags` (array): Tags for searchability and filtering (e.g. ["sales", "billing", "v2"]). - `template` (string, required): The template file. Accepts a local file path (e.g. /home/user/invoice.docx), a URL (https://example.com/template.docx), or a base64-encoded string. Supported formats: DOCX, XLSX, PPTX, ODT, ODS, ODP,… - `versioning` (boolean): Enable template versioning (default: true). When true, a stable Template ID is generated and multiple versions can be managed under it. When false, behaves as legacy mode and returns only a templateI… Output parameters: - `id` (string): Stable Template ID (when versioning is enabled). - `name` (string): Template display name. - `size` (number): Template size in bytes. - `templateId` (string): Template ID returned in legacy/non-versioned mode. - `type` (string): Detected template file type. - `versionId` (string): Version ID (SHA-256) of this uploaded version. ### `update_template_metadata` (~227 tokens) Update Template Metadata Update the metadata of a stored template: name, comment, category, tags, deployment timestamp, or expiration. Use deployedAt to activate a specific version for rendering. Use expireAt to schedule or trigger immediate deletion. Input parameters: - `category` (string): New category. - `comment` (string): New free-text comment. - `deployedAt` (integer): Unix timestamp (seconds) to set as the deployment time for this version. Carbone picks the version with the most recent deployedAt when rendering. Use 42000000000 to deploy immediately (special "NOW"… - `expireAt` (integer): Unix timestamp (seconds) at which this template will be automatically deleted. Use 42000000000 to delete immediately. - `name` (string): New display name. - `tags` (array): New list of tags — replaces existing tags entirely. - `templateId` (string, required): Template ID (64-bit) or Version ID (SHA-256) to update. Using a Template ID updates the metadata shared by all versions. Using a Version ID updates only that specific version. ### `delete_template` (~152 tokens) Delete Template Delete a stored Carbone template. This is a soft delete: the template is marked for garbage collection and removed after a delay (default 24 hours). You can delete by Template ID (removes all versions) or by Version ID (removes only that specific version). For immediate or scheduled deletion, use update_template_metadata with expireAt = 42000000000 (NOW) or a future Unix timestamp. Input parameters: - `templateId` (string, required): Template ID (64-bit) or Version ID (SHA-256) to delete. Template ID — deletes the template record and all its versions. Version ID — deletes only that specific version, leaving other versions intact.… ### `download_template` (~255 tokens) Download Template Download the original source file of a stored Carbone template (e.g. the DOCX, XLSX, PPTX, or HTML file that was uploaded). Use this to inspect, edit, or back up a template. Pass a Template ID to download the currently deployed version, or a Version ID to download a specific version. Input parameters: - `asAttachment` (boolean): If true, return the template as a downloadable file attachment (base64 resource) instead of inline text/image. Useful in HTTP mode where outputPath is unavailable. Default: false. Ignored when output… - `outputPath` (string): Optional local file path to save the template file to (e.g. "/home/user/template.docx" or "~/template.docx"). When set, the file is written to disk and the tool returns the saved path + size instead… - `templateId` (string, required): Template ID (64-bit) or Version ID (SHA-256) to download. Template ID — downloads the currently deployed version of the template. Version ID — downloads that exact version regardless of deployment st… ### `get_api_status` (~40 tokens) API Status Check Carbone API health and version. Returns the current API version and a status message. Useful for verifying connectivity and confirming which Carbone version is active. Output parameters: - `message` (string): Status message returned by the API. - `version` (string): The running Carbone API version. ### `get_capabilities` (~46 tokens) Capabilities Returns a summary of all Carbone capabilities: supported formats, features, tool usage examples, and links to full documentation. Call this first if you are unsure what Carbone can do. ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp#diagnostics ## Score history - 2026-08-03: 66 - 2026-08-02: 66 - 2026-08-01: 65 - 2026-07-31: 65 - 2026-07-30: 65 - 2026-07-29: 64 - 2026-07-28: 64 - 2026-07-27: 63 - 2026-07-26: 62 ## Links - Remote endpoint: https://mcp.carbone.io/ - Repository: https://github.com/carboneio/carbone-mcp - Website: https://carbone.io/ - Changelog RSS feed: https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp/changelog.xml - Changelog JSON feed: https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp/changelog.json - HTML version of this page: https://verifymcp.io/servers/io-carbone-carbone-mcp/mcp