> ## Documentation Index
> Fetch the complete documentation index at: https://print.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP reference

> The Print.App MCP server for developers: connecting every client and API, the tools, and how signing in works.

> [!TIP]
>
> Just want to connect? Follow [MCP server](https://print.app/docs/mcp/server.md), or hand your agent the [Quickstart for agents](https://print.app/docs/mcp/quickstart-agents.md).

Print.App runs a remote [Model Context Protocol](https://modelcontextprotocol.io) server, so AI agents such as ChatGPT, Claude, Cursor or your own can work in your account through the [REST API](https://print.app/docs/api-reference/v2/introduction.md): build a design from a brief, look at it and fix it, then put it on a product.

```
https://api.print.app/mcp
```

A client connects one of two ways, both with a [secret key](https://print.app/docs/api-reference/v2/authentication.md) of your store:

* **Sign in (OAuth):** apps such as ChatGPT and Claude open a Print.App page where you paste the key and allow access. The app never sees the key: it gets its own access, tied to that key.
* **Send the key:** developer tools and your own code send `Authorization: Bearer sk_…` with every request.

> [!WARNING]
>
> An agent connected with your key can change and delete anything in your account that the API can. Create a separate key for each app or agent, labelled so you recognise it. Revoking the key in the admin disconnects it, including apps that signed in with it.

## Connect a client

**ChatGPT**

1. In ChatGPT, add a custom MCP server (it is in developer mode; see OpenAI's [Connecting custom MCP servers in ChatGPT](https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt) for where it is on your plan).
2. Name it Print.App, enter the URL `https://api.print.app/mcp`, and choose **OAuth** as the authentication.
3. ChatGPT opens the Print.App connect page. Paste a secret key of your store and click **Allow access**.

**Claude**

In Claude (claude.ai or the desktop app), add a custom connector with the URL `https://api.print.app/mcp`, then click **Connect**. Claude opens the Print.App connect page: paste a secret key of your store and click **Allow access**.

**Claude Code**

```bash theme={null}
claude mcp add --transport http printapp https://api.print.app/mcp \
  --header "Authorization: Bearer sk_…"
```

**Cursor**

In `.cursor/mcp.json` (or your global Cursor MCP settings):

```json theme={null}
{
  "mcpServers": {
    "printapp": {
      "url": "https://api.print.app/mcp",
      "headers": { "Authorization": "Bearer sk_…" }
    }
  }
}
```

**VS Code**

In `.vscode/mcp.json`:

```json theme={null}
{
  "servers": {
    "printapp": {
      "type": "http",
      "url": "https://api.print.app/mcp",
      "headers": { "Authorization": "Bearer sk_…" }
    }
  }
}
```

**Claude API**

With the [MCP connector](https://docs.claude.com/en/docs/agents-and-tools/mcp-connector) of the Messages API:

```json theme={null}
{
  "mcp_servers": [{
    "type": "url",
    "url": "https://api.print.app/mcp",
    "name": "printapp",
    "authorization_token": "sk_…"
  }]
}
```

**Codex**

In `~/.codex/config.toml`, with the key in an environment variable rather than in the file:

```toml theme={null}
[mcp_servers.printapp]
url = "https://api.print.app/mcp"
bearer_token_env_var = "PRINTAPP_SECRET_KEY"
```

```bash theme={null}
export PRINTAPP_SECRET_KEY=sk_…
```

**OpenAI API**

With the [remote MCP tool](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) of the Responses API:

```json theme={null}
{
  "tools": [{
    "type": "mcp",
    "server_label": "printapp",
    "server_url": "https://api.print.app/mcp",
    "authorization": "sk_…",
    "require_approval": "never"
  }]
}
```

Send `authorization` with every request: OpenAI doesn't store it. Leave out `require_approval` to approve each tool call yourself.

Any MCP client that speaks Streamable HTTP works the same way, sending a key or signing in. The server is stateless: it answers JSON over `POST` and keeps no sessions.

### How signing in works

Clients find the sign-in on their own: a request without credentials gets a `401` that points to `https://api.print.app/.well-known/oauth-protected-resource/mcp`, and from there to the authorization server's metadata at `https://api.print.app/.well-known/oauth-authorization-server`. It supports dynamic client registration and client ID metadata documents, PKCE (S256) and refresh tokens. Access lasts an hour and the client renews it on its own; it stops within a minute of the key it was approved with being revoked.

Redirect URIs must be `https` addresses, as ChatGPT's and Claude's are. Apps that sign in through a local address (`http://localhost:…`) can't register; send the key as a header from those instead.

## What an agent can do

| Area | Tools |
| - | - |
| Account | `get_account` |
| Designs | `list_designs`, `get_design`, `create_design`, `update_design`, `duplicate_design`, `delete_design`, `manage_pages` |
| Page content | `get_design_content`, `edit_design`, `design_ops_reference`, `preview_design` |
| Design folders | `list_design_folders`, `manage_design_folder` |
| Files | `list_files`, `get_file`, `upload_file`, `manage_file` |
| Graphic folders | `list_graphic_folders`, `manage_graphic_folder` |
| Fonts | `list_fonts`, `manage_font` |
| Palettes | `list_palettes`, `manage_palette` |
| Products | `list_products`, `get_product`, `set_product_designs` |
| Connectors | `inspect_product_page`, `test_connector`, `list_connectors`, `manage_connector` |
| Profiles | `list_profiles`, `manage_profile` (resource and PDF profiles) |
| Settings | `get_settings`, `update_settings` |
| Projects | `list_projects`, `get_project`, `manage_project` |
| Editor links | `create_editor_link`, `manage_editor_link` |

Each tool calls the REST API with your key, so the same rules, limits and errors apply. Tools that only read are marked read-only; tools that can delete are marked destructive, so clients that ask before running those will ask.

`update_design` also sets what a design uses (its connectors, resource profiles and PDF profile) and its own settings over the store's.

The server also offers one prompt, `set_up_connector` (*Set up a connector*), for clients that list MCP prompts: it takes a product page and a goal, and writes out the steps below for the agent.

## How an agent builds a design

1. `create_design` at the trim size, with bleed and a safe margin.
2. `upload_file` for logos, photos and SVG graphics.
3. `get_design_content` to read the page size and safe area, then `edit_design` with a batch of operations: text, shapes, graphics, photo frames, QR codes, calendars. The batch saves as one change, or not at all.
4. `preview_design` returns images of the pages, so the agent can look at its work and fix what it sees with another `edit_design`.
5. `set_product_designs` to sell it on a store product, or `create_editor_link` to share it.

Try it with a prompt like *"Create a two-sided 85 × 55 mm business card for a bakery called Crumb & Co with 3 mm bleed: logo from https\://…/logo.png, the name, job title and phone as fields customers fill in, and a warm palette. Show me both sides."*

## How an agent sets up a connector

1. `inspect_product_page` reads the product page of your store: each option control with a selector that finds it and the choices it sends, the Print Options fields with their roles, and the designs the product opens.
2. `get_design` and `preview_design` show the design's pages.
3. `test_connector` plays the connector, before it is saved, against the design for every choice: what the page sends, which mapping matches, what the editor does, with images of the pages each choice shows. It reports what stands in the way: a selector that finds nothing, choices without a mapping, pages the design doesn't have, a design that isn't on the product, another connector fighting this one.
4. `manage_connector` saves it and attaches it to the designs (`create` with `designIds`), and `test_connector` runs once more with its id.

The walk-through for store owners is [Set up connectors with AI](https://print.app/docs/mcp/connectors.md).

## Things to know

* **Page content** can only be edited on accounts that use the new editor. Others get `editor_not_supported`.
* **SVG graphics go in as files.** The firewall in front of the API refuses requests that carry markup, so an agent should upload an SVG with `upload_file` and place it as an `asset`, not write SVG into an operation. It stays vector in print. A tool call with SVG or HTML in its arguments fails with an HTTP `403` before it reaches the server, so the client reports a connection error rather than a tool error.
* **Fonts** must be families your account has. `list_fonts` lists them; `manage_font` imports any Google font.
* **Previews** are redrawn each time a design is saved. They are for checking a layout; the PDF is made from the design itself.
* **Settings** that run code in your store (custom JS and CSS), send data elsewhere (webhook addresses) or delete customers' projects can't be changed through the MCP or the API, and the editor in use is read-only: change those in the dashboard. `update_settings` is marked destructive, so clients ask before running it.
* **Product pages** are read as your server sends them, and only pages of your own store. Options a theme builds in JavaScript after the page loads aren't seen; a store behind a password answers with its password page (give `test_connector` the choices as `values` instead).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.