# ZeroWidth Napkin (remote · api.zerowidth.ai) Draw boards, write docs and sheets, and build decks with your brand in Napkin. - Trust score: 72/100 (medium) - Change this week: +3 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-10-23 ## Components - remote · `api.zerowidth.ai`: 72/100 (this document), [markdown](https://verifymcp.io/servers/ai-zerowidth-napkin/mcp-x-napkin.md), [page](https://verifymcp.io/servers/ai-zerowidth-napkin/mcp-x-napkin) ## Channel facts - Endpoint: `https://api.zerowidth.ai/mcp/x/napkin` - Transports: `streamable-http` - Auth: `none` - Version: `1.0.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-10-23. - **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 (comments_resolve). - 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**: 81/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 27325 tokens (~135/item across 202 items; 68 tools + 134 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 50/100 - Stability observed for 15 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 93/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 78% of tool parameters carry a description. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation. - An AI judge read all 69 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### How do I install the ZeroWidth Napkin MCP server? ZeroWidth Napkin is a hosted endpoint at https://api.zerowidth.ai/mcp/x/napkin, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http ai-zerowidth-napkin 'https://api.zerowidth.ai/mcp/x/napkin' ``` ### Cursor ```json { "mcpServers": { "ai-zerowidth-napkin": { "url": "https://api.zerowidth.ai/mcp/x/napkin" } } } ``` ### VS Code ```json { "servers": { "ai-zerowidth-napkin": { "type": "http", "url": "https://api.zerowidth.ai/mcp/x/napkin" } } } ``` ### Codex ```toml [mcp_servers.ai-zerowidth-napkin] url = "https://api.zerowidth.ai/mcp/x/napkin" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "ai-zerowidth-napkin": { "type": "remote", "url": "https://api.zerowidth.ai/mcp/x/napkin", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add ai-zerowidth-napkin --url 'https://api.zerowidth.ai/mcp/x/napkin' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: ai-zerowidth-napkin: url: "https://api.zerowidth.ai/mcp/x/napkin" ``` ### Netclaw ```json { "McpServers": { "ai-zerowidth-napkin": { "Transport": "http", "Url": "https://api.zerowidth.ai/mcp/x/napkin" } } } ``` ### Vellum ```bash assistant mcp add ai-zerowidth-napkin -t streamable-http -u 'https://api.zerowidth.ai/mcp/x/napkin' ``` ### Other ```json { "mcpServers": { "ai-zerowidth-napkin": { "type": "http", "url": "https://api.zerowidth.ai/mcp/x/napkin" } } } ``` 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-10-23 (score 72, +1) No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-22 (score 71, 0) - [security] Tool “search_docs” rewrote its description, which is the text the model reads - [cosmetic] “napkin_deck_compose” added an optional parameter “previews” ### 2026-10-21 (score 71, +1) No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-19 (score 70, +1) No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-17 (score 69, 0) - [security] Tool “search_workspace” rewrote its description, which is the text the model reads - [cosmetic] “search_workspace” added an optional parameter “folderId” - [cosmetic] “search_workspace” reworded the description of “kinds” - [cosmetic] “search_workspace” reworded the description of “q” ### 2026-10-16 (score 69, +1) No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-15 (score 68, 0) - [security] Tool “napkin_interfaces_create” rewrote its description, which is the text the model reads - [security] Tool “napkin_interfaces_get” rewrote its description, which is the text the model reads - [security] Tool “napkin_interfaces_view” rewrote its description, which is the text the model reads - [security] Tool “napkin_interfaces_write” rewrote its description, which is the text the model reads - [functional regression] Schema quality: 113 → 134 - [functional] Server version: 0.0.0 → 1.0.0 - [cosmetic] “napkin_interfaces_view” added an optional parameter “size” - [cosmetic] “napkin_interfaces_view” added an optional parameter “steps” - [cosmetic] “napkin_interfaces_create” reworded the description of “starter” ### 2026-10-14 (score 68, 0) - [security] New tool “napkin_interfaces_grant_data”, which the server declares destructive - [security] New tool “napkin_tables_delete_records”, which the server declares destructive - [security] Tool “napkin_interfaces_create” rewrote its description, which is the text the model reads - [security] Tool “napkin_interfaces_get” rewrote its description, which is the text the model reads - [security] Tool “napkin_interfaces_write” rewrote its description, which is the text the model reads - [functional regression] Schema quality: 20409 → 22927 - [functional] New resource “prism/synthetic-panels” - [functional] New tool “napkin_tables_add_columns” - [functional] New tool “napkin_tables_add_records” - [functional] New tool “napkin_tables_add_view” - [functional] New tool “napkin_tables_create” - [functional] New tool “napkin_tables_get” - [functional] New tool “napkin_tables_query” - [functional] New tool “napkin_tables_update_records” - [cosmetic] “napkin_interfaces_write” added an optional parameter “append” - [cosmetic] “napkin_interfaces_write” reworded the description of “body” ## MCP tools (68) ### `search_docs` (~111 tokens) Search ZeroWidth docs Search ZeroWidth product documentation. Returns matching pages with title, slug, public URL, and a query-relevant snippet. Use this when the user asks about a ZeroWidth product (Compass, Workbench, Caliper, Prism, Ledger, Napkin, the assistant), an API behavior, or a policy. No authentication required — the docs corpus is public. Input parameters: - `limit` (integer): Max number of results. Defaults to 10. - `query` (string, required): Search query — keywords or natural-language phrase. ### `get_doc` (~73 tokens) Fetch ZeroWidth doc by slug Fetch the full Markdown body of a specific docs page by its slug. Use this after `search_docs` when the user needs the complete content of a page. No authentication required. Input parameters: - `slug` (string, required): Page slug. Accepts 'compass/api', '/compass/api', or 'docs/compass/api'. ### `list_docs` (~75 tokens) List ZeroWidth docs pages Enumerate all available docs pages, optionally filtered by product (e.g. 'compass', 'legal', 'overview'). Use this to discover what slugs exist before calling `get_doc`. No authentication required. Input parameters: - `product` (string): Optional product slug filter (e.g. 'compass', 'legal', 'overview'). ### `comments_list` (~105 tokens) Read an entity's comment threads Lists the comment threads on one workspace entity (open first, then resolved) with authors and timestamps. Read this before weighing in on contested work — the threads are where disagreement lives before it becomes a decision. Input parameters: - `entityId` (string, required) - `entityKind` (string, required): What the thread hangs on. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `comments_create` (~184 tokens) Comment on an entity Posts a comment on a workspace entity — a new thread, or a reply when rootId is given. Use it to leave findings where the discussion already lives (an eval result on the flow being debated, a summary on a long thread). Mention people via mentionedUserIds (from workspace member ids) to ring their notification bell; never mention someone who didn't ask to be pulled in. Input parameters: - `approvalId` (string) - `body` (string, required) - `entityId` (string, required) - `entityKind` (string, required): What the thread hangs on. - `mentionedUserIds` (array) - `rootId` (string): Reply into this thread; omit to start a new one. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `comments_resolve` (~118 tokens) Resolve or reopen a thread Sets a comment thread's resolved state (rootId = the thread's root comment id). Resolve ONLY when the human asked or the thread's question is demonstrably settled — and say what settled it in a reply first. Reopening is for new evidence. Input parameters: - `approvalId` (string) - `resolved` (boolean, required) - `rootId` (string, required) - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_boards_list` (~225 tokens) List Napkin sketches Lists sketch boards in the active workspace — name, id, kind (sketch / deck), shape count, last activity. Boards are SPATIAL canvases (drawing, diagrams); the markdown DOCUMENTS are docs — napkin_docs_list. Archived boards are hidden unless `includeArchived`; `q` narrows by name. When the user mentions a sketch, drawing, whiteboard, or napkin, find it here, then LOOK at it with `napkin_boards_view` before discussing its contents. When referring the user to a sketch in your reply, put `[[board:ID]]` alone on its own line — it renders as a clickable card with a live thumbnail. Input parameters: - `includeArchived` (boolean): Also list archived boards (default false). - `kind` (string): Only sketches or only decks. - `q` (string): Name contains (case-insensitive). - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_boards_get` (~155 tokens) Read a Napkin board's shapes Returns a board's shapes as data — each with its id, kind, position, size, and text — so you can TARGET one to change or remove with napkin_draw (`updates` / `deletes` take these ids and absolute board coordinates). Pen strokes come back as a point count, not the points. For what the board LOOKS like, use napkin_boards_view instead. Board ids come from napkin_boards_list. Input parameters: - `boardId` (string, required): Napkin board id (from napkin_boards_list). - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_boards_view` (~135 tokens) View a Napkin sketch (rendered image) Renders the sketch board to an image and returns it so you can SEE what's drawn — layout, arrows, handwriting-style strokes, sticky notes — not just data about it. Use this before answering any question about a sketch's contents, and cite the board when you do — `[[board:ID]]` alone on its own line embeds the sketch card in your reply. Input parameters: - `boardId` (string, required): Napkin board id to render. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_boards_update` (~203 tokens) Rename, describe, archive, or share a Napkin board Edits a board's details: name, description, visibility, or `archived` (true takes it out of the gallery; false brings it back — the recovery move for a board you created by mistake or the user no longer wants). Board ids come from napkin_boards_list. Boards are working material: no approval card, every change attributed. Input parameters: - `archived` (boolean) - `boardId` (string, required): Napkin board id (from napkin_boards_list). - `description` (string) - `name` (string) - `visibility` (string): Who can see it: PRIVATE (only the user), WORKSPACE (every member, the default), or SHARED (specific people, granted afterwards). Say 'make it private' → PRIVATE. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_deck_outline` (~163 tokens) Read a deck's outline (markdown) Returns a Napkin deck as a markdown outline — one section per slide in presentation order, with slide titles, text content (bold + bullets preserved), empty layout stubs still awaiting content, and a summary of drawn marks. This is the cheap way to know what a deck SAYS; use `napkin_slide_view` when you need to see how a specific slide LOOKS. Works on any board that has slides. Cite the deck with `[[board:ID]]` alone on its own line. Input parameters: - `boardId` (string, required): Napkin board id (a deck). - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_slide_view` (~167 tokens) View one deck slide (rendered image) Renders a single slide of a Napkin deck to an image — exactly what present mode shows, cropped to the slide. Navigate by 1-based `slide` number in presentation order (get the map from `napkin_deck_outline` first; the result echoes `slideIndex`/`slideCount` so you can step through a deck slide by slide). Use this to check visual layout, drawings, and images that the text outline can't carry. Input parameters: - `boardId` (string, required): Napkin board id (a deck). - `slide` (integer, required): 1-based slide number in presentation order. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_boards_create` (~168 tokens) Create a Napkin board Creates a blank Napkin board — a sketch (free canvas) or a deck (slides). NOT for written documents: 'draft/write a doc, note, memo' is napkin_docs_create. Use when the user asks for one, or proactively when a sketch/deck would carry the conversation better than words; hand it over with `[[board:ID]]` alone on its own line. For a deck with content, prefer `napkin_deck_write` (one call, whole deck). Input parameters: - `kind` (string): Defaults to "sketch". - `name` (string, required): Board name. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_deck_write` (~323 tokens) Write a whole deck from a markdown outline Creates a deck from a markdown outline — the SAME dialect `napkin_deck_outline` reads back, so any deck you've read shows the format. Decks are SLIDES for presenting; a prose document ('write this up', 'draft a doc') is napkin_docs_create instead. Rules: `## Heading` starts a slide (heading becomes the slide title and its biggest text block); optional trailing `[layout: title | section | title-body | title-lead | two-column | three-column | comparison | statement | quote | closing | blank]`; body lines fill the layout's remaining text areas in order, split into areas by a line containing only `---`; `- ` bullets are kept as bullets. Slides default to title-body (or title, when bodyless). Layout text areas you don't fill stay as visible prompts for the user. Example: \## Q3 Review [layout: title] What happened, what's next \## Revenue [layout: title-body] \- up 40% QoQ \- churn flat \## Bets [layout: two-column] Double down on decks \--- Sunset legacy plans After writing, cite the deck with `[[board:ID]]` alone on its own line — the user opens it from there. Input parameters: - `name` (string, required): Deck name. - `outline` (string, required): The markdown outline (dialect above). - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_slide_add` (~210 tokens) Add a slide to a deck Appends one slide to an existing deck. Pick a layout (title | section | title-body | title-lead | two-column | three-column | comparison | statement | quote | closing | blank), give the title, and optionally `content` — markdown for the layout's remaining text areas, split by `---` lines (two-column/comparison take one block per column). Check the deck first with `napkin_deck_outline`. Input parameters: - `boardId` (string, required): Napkin board id (a deck). - `content` (string): Markdown body — blocks split on `---` lines. - `layout` (string, required): Layout key: title | section | title-body | title-lead | two-column | three-column | comparison | statement | quote | closing | blank. - `title` (string): Slide title. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_slide_fill` (~165 tokens) Fill a slide's empty text areas Fills a slide's empty layout text areas by NAME — the names `napkin_deck_outline` surfaces as `[empty text stub: "…"]`. Pass `texts` mapping those exact names to content (markdown `- ` bullets welcome). Read the outline first to see which stubs a slide still has open. Input parameters: - `boardId` (string, required): Napkin board id (a deck). - `slide` (integer, required): 1-based slide number in presentation order. - `texts` (object, required): Placeholder name → content, e.g. {"Add a title": "Q3 Review"}. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_draw` (~475 tokens) Draw on a Napkin board Draws shapes, strokes, and labels on a board — diagram on a sketch, annotate a deck slide — and, via `updates` / `deletes`, changes or removes shapes that are already there (ids from napkin_boards_get; the fix for something you drew wrong). For NEW elements never compute absolute board coordinates: with `slide`, coordinates are slide-local — (0, 0) top-left to (960, 540) bottom-right of that slide. Without `slide` (sketches), (0, 0) is the top-left of the existing content — the same area `napkin_boards_view` renders, so place by what you saw there; on an empty board just start at (0, 0). Example — circle a slide's title and margin-note it: {"boardId": "…", "slide": 2, "elements": [ {"type": "ellipse", "x": 60, "y": 40, "w": 400, "h": 90, "color": "#dc2626"}, {"type": "arrow", "x": 560, "y": 140, "x2": 470, "y2": 90, "color": "#dc2626"}, {"type": "text", "x": 575, "y": 130, "w": 260, "text": "tighten this claim", "color": "#dc2626"} ]} After drawing, cite the board with `[[board:ID]]` alone on its own line. Input parameters: - `boardId` (string, required): Napkin board id. - `deletes` (array): Ids of existing shapes to remove (from napkin_boards_get). - `elements` (array): New elements to draw, painted in order. - `slide` (integer): 1-based slide number (decks only) — makes coordinates slide-local. - `updates` (array): Existing shapes to change — move, resize, retext, restyle. Read napkin_boards_get first for ids and current geometry. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_deck_set_theme` (~330 tokens) Set a deck's theme Paints every slide of a deck with a theme — slide background, heading and body typefaces, and text colors — in one call, the same as picking it in the deck's theme menu. Font sizes are kept. Prefer "brand" (the workspace's own brand kit) unless the user asks for something else. Built-in themes: plain (Helvetica on white. Gets out of the way.); editorial (Garamond headings on cream. Reads like a document.); stage (Helvetica, light on dark, for a projected room.); blueprint (Consolas headings on mist. For technical decks.); warm (Rounded on amber. Softer than it sounds.); notebook (Marker headings. Keeps the sketchbook feel.). For one-off colors or sizes on a single shape, use napkin_draw's `updates` instead. Check the result with napkin_slide_view. Input parameters: - `accent` (string): Brand themes only: the name of one of the kit's colors to use as this deck's accent instead of the kit's own — for a deck about one product or campaign that has its own color in the brand. - `boardId` (string, required): Napkin board id (a deck). - `theme` (string, required): `brand` for the workspace's brand kit, `brand:` for a particular kit (napkin_brand_list), or a built-in theme key. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_slide_update` (~229 tokens) Move or change a deck slide Changes one slide as a whole: move it to another position in the deck (`moveTo`, 1-based — the other slides shift around it), hide it from the show without deleting it (`skipped`), show or hide its slide number (`pageNumber`), or replace its speaker notes (`notes`, markdown). Slide numbers come from napkin_deck_outline. To change what's ON the slide, use napkin_slide_fill or napkin_draw. Input parameters: - `boardId` (string, required): Napkin board id (a deck). - `moveTo` (integer): New 1-based position for this slide. - `notes` (string): Speaker notes (markdown); replaces the current notes. - `pageNumber` (boolean): Show the slide number on this slide. - `skipped` (boolean): true hides the slide from present mode and exports. - `slide` (integer, required): 1-based slide number in presentation order. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_list` (~86 tokens) List brand kits Lists the workspace's brand kits: id, name, description, and which one is the workspace's brand (`isDefault`). Most workspaces have one. Use napkin_brand_get to read a kit. Input parameters: - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_get` (~221 tokens) Read the brand Reads a brand kit — the workspace's brand unless you name another. READ THIS BEFORE writing or designing anything for the workspace: a deck, a doc, an interface, copy. Returns `brief` (the whole kit as markdown: every section — overview, voice, colors, typography, imagery, motion, and whatever else the team wrote — with the reason behind each rule; follow the reasons when a case isn't covered), `css` (the `--brand-*` variables; interfaces already link it as brand.css, so style with var(--brand-accent) etc. rather than hex values), and `tokens` (the resolved values Napkin uses). Before any kit exists it returns values from the workspace's colors with `kit: null`. Input parameters: - `kitId` (string): A brand kit id from napkin_brand_list. Omit for the workspace's brand. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_check` (~160 tokens) Check writing against the brand Finds words the brand says to avoid in a piece of writing, with what to say instead and why. Pass `text`, or a deck (`boardId`) or doc (`docId`) to check its words. Run it on your own drafts before handing them back. Input parameters: - `boardId` (string): A deck or sketch to check. - `docId` (string): A doc to check. - `kitId` (string): A brand kit id from napkin_brand_list. Omit for the workspace's brand. - `text` (string): Text to check. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_apply` (~249 tokens) Apply the brand to a piece Restyles a piece in the brand — the workspace's brand unless you name a kit. `deck` (a board id): every slide gets the brand's background, typefaces, and text colors; sizes are kept. `interface` (an interface id): rewrites its brand.css, so anything styled with var(--brand-*) updates. `accent` makes one of the kit's colors the piece's accent — use it when the piece is about one product or campaign that has its own color in the brand (read the kit's Colors section to see which). Docs need nothing — they read the brand when exported. Check a deck afterwards with napkin_slide_view. Input parameters: - `accent` (string): Name of one of the kit's colors to use as this piece's accent. - `deck` (string): Board id of a deck. - `interface` (string): Interface id. - `kitId` (string): A brand kit id from napkin_brand_list. Omit for the workspace's brand. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_draft` (~503 tokens) Draft a brand kit Creates a new brand kit, or edits one that is NOT the workspace's brand. Use it when someone asks you to put their brand together (from their site, a deck, or what they tell you) or to try a variation. You can't change the workspace's brand itself — make a draft and tell the user they can choose it in Napkin's Brand section. A kit is a document of sections, each with `title`, `kind` (overview, voice, colors, typography, logo, imagery, motion, layout, examples, custom), markdown `body`, and `rules` ({rule, why}); colors sections hold `swatches` ({name, value: 6-digit hex, note}), typography sections hold `faces` ({name: what it's for, family: a font name or sans / serif / mono / rounded / marker, note}), voice sections hold `use` and `avoid` ({term, instead, why}), and any section can hold `assets` ({fileId: an image already in the workspace's files, name, note, backdrop: hex}) — logo versions, example images — and `links` ({url, title, note}). An examples section holds work that gets the brand right: screenshots as assets and pages as links, each with a note on what makes it good. Exact numbers (timings, spacing) go in the section's prose. New kits start with empty standard sections plus the workspace's colors. `content.sections` upserts by title (or id): fields you pass replace, lists inside replace, sections you don't mention are kept; `removeSections` drops by title. `content.uses` says how Napkin uses the brand — color roles (ink, muted, background, surface, accent, accent2) and fonts (heading, body, mono) — by swatch or face NAME. Give every rule a `why`: the reason is what lets people decide cases the rule doesn't cover. Input parameters: - `content` (object) - `description` (string) - `fromKitId` (string): New kits only: start from this kit's values. - `kitId` (string): Kit to edit. Omit to create a new kit. - `name` (string) - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_fonts` (~178 tokens) Get a brand's font files Gets the font files for a kit's typefaces from Google Fonts and keeps them in the kit, so decks, slide pictures and the canvas draw the brand's real typefaces instead of a stand-in. Only typefaces that name a family (like Poppins) and don't have files yet are fetched. Works on any kit, including the workspace's brand: it adds the files for the typefaces the kit already names and changes nothing else. A typeface Google doesn't have is reported back; the user can upload its files in the kit's typography section. Input parameters: - `kitId` (string): Kit to fetch fonts for. Omit for the workspace's brand. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_examples` (~138 tokens) Look at the brand's examples Shows you the pictures in a kit's Examples sections — screenshots of work that gets the brand right — with each one's note on what makes it good, plus the example links. Look before you design a deck, page or interface in the brand, and hold your work to the same bar: the layouts, density, type sizes and use of color you see there. Input parameters: - `kitId` (string): Kit to look at. Omit for the workspace's brand. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_add_files` (~298 tokens) Add pictures to a brand kit Adds pictures to a brand kit section — logo versions, product marks, example screenshots, imagery. Each file comes from a public https `url` (fetched by the server) or, for a small file that isn't online, base64 `data` with a `filename`. PNG, JPEG, WebP, GIF and SVG, up to 20 MB each. Every file becomes a workspace file and an asset on the section, appended after the ones already there. Give each a `name` and a `note` saying what it's for; on logo sections set `backdrop` to the hex of the ground it's made for (#ffffff for a dark logo, #000000 for a reversed one), which is how pages pick the right version. Same rule as napkin_brand_draft: you can change any kit except the workspace's brand. Files that fail are reported and the rest still land. Input parameters: - `files` (array, required) - `kind` (string): Only when no section has that title yet: the kind of section to make. - `kitId` (string, required): The kit to add to (napkin_brand_list). - `section` (string, required): Title of the section to add them to, like Logo, Imagery or Examples. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_brand_view` (~230 tokens) Look at a brand's pictures Look at the pictures in a brand kit — logos, product marks, footage stills, layout references, examples — before you use them. Without `section` or `names` it lists every picture by section with its note, so you know what exists. With `section` (a section title, like Imagery) or `names` (pictures' names as the brief lists them) it shows you those pictures, up to 8 at a time. Look before you build a design around a picture: whether a photo has room for text, which part of it carries the color, and whether it suits texture inside type are things you can only tell by seeing it. Input parameters: - `kitId` (string): A kit from napkin_brand_list. Omit for the workspace's brand. - `names` (array): Show these pictures, by name. - `section` (string): Show the pictures in this section. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_deck_export` (~229 tokens) Export a deck as images Exports a deck's slides as PNG files at each slide's real pixels — a square post at 1080×1080, a story at 1080×1920, a leaderboard at 728×90 — ready to upload to an ad platform or a social post. One slide comes back as a PNG; several as a .zip named by deck, slide and size. Hidden slides are left out. The file is saved to the workspace's files; give the user `downloadUrl` (it opens for anyone signed in to the workspace) and say it's also in their files. Slide numbers and the workspace mark aren't drawn. For a PDF or PowerPoint, the user exports from the deck's File menu. Input parameters: - `boardId` (string, required): The deck to export. - `slides` (array): Just these slides (1-based, as the deck shows them). Omit for every slide. - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_layouts_list` (~189 tokens) List slide layouts Lists the slide layouts napkin_deck_compose can build from — the brand kit's own first, then the built-in ones — with when to use each and the slots it takes (`needs` must be filled; `takes` are optional). Every layout adapts to every size, fits its text, and uses the brand's colors, faces and logos; the logo fills itself in. Pick by what the slide has to say: one line (statement), a number (stat), a quote, a list (points, steps), an event, a carousel (cover, inner, closing), a picture (image-top, image-full, split, corner, product-shot), or a display ad (banner). Input parameters: - `workspace` (string): Workspace slug. Personal tokens with no default workspace MUST pass this; tokens with a default can override per call. Ignored for workspace API keys. ### `napkin_deck_compose` (~1731 tokens) Build a designed deck Builds a designed deck: each slide is a layout with its slots filled, or HTML and CSS you write; a real browser lays it out, and it becomes an ordinary Napkin deck people can edit. Use this whenever a deck should look designed — it's how to get layout, big numbers, color blocks, and pictures right. LAYOUTS FIRST \- For ads, posts, carousels and title slides, start from a layout (napkin_layouts_list): give `layout` and `slots` instead of `html`. Layouts adapt to every size, fit their text, keep to each size's safe zones, and use the brand's own logos. A slide made from a layout remembers it, so when someone resizes it, it's laid out again instead of scaled. \- A set of ads is one slide with `sizes`: ["1:1","4:5","9:16","1.91:1"] — each size gets its own arrangement. \- Write HTML only for something no layout does. HOW TO WRITE A SLIDE \- `html` is the inside of one slide: a `.slide` box 960×540 px (the deck's own size if it has one). Margins are reset; lay out with flexbox or grid, padding and gap. Put each slide's CSS in a