Model Context Protocol (MCP)

Overview

Temway's Model Context Protocol (MCP) server lets an AI assistant like Claude or ChatGPT build and edit your emails and layouts for you — you describe what you want in plain language, and the assistant does the clicking. Start a new email from your branding, drop in a button, tweak the headline, preview it, and publish — all from a conversation.

There is nothing to install or build. Temway hosts the MCP server, and both Claude and ChatGPT connect to it over the standard MCP Streamable HTTP transport. Every connection is scoped to a single workspace, so an assistant can only ever touch the emails and layouts in that workspace.

How you connect depends on the client:

Web connectors (claude.ai, ChatGPT) use a standard sign-in flow — you paste one URL, sign in to Temway, and pick the workspace to share. No key to manage.
Desktop and programmatic clients (Claude Desktop, scripts) use a tmw_live_… API key that you paste into the client config. You can narrow the key to read-only for an assistant that can look but not change.

The MCP server is available on every plan, including Free — it rides on the API access that ships with every workspace, so there is nothing extra to enable or buy. See the billing and plans page for what each tier includes.

Get an API key

API keys are created from the API Keys entry in the Temway app's main sidebar. Create one dedicated to your AI assistant (you can name it "Claude", for example, so you remember what it's for).

The full key starts with tmw_live_ and is shown only once at creation — copy it somewhere safe.
A new key can do everything by default: read and edit emails and layouts, preview, publish, and test-send.
Want a read-only assistant? Narrow the scopes when you create the key (for example, just emails:read and layouts:read).
The key is tied to a single workspace. Your assistant will only ever see that workspace's content — and the workspace is derived automatically from the key, so you never have to paste a workspace ID into your AI client.

Connect Claude Desktop

Open the Claude desktop app's developer config file and add a temway entry to mcpServers with the Temway MCP URL and your API key in an Authorization header.

Config file location: macOS — ~/Library/Application Support/Claude/claude_desktop_config.json · Windows — %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "temway": {
      "url": "https://mcp.temway.com/mcp",
      "headers": {
        "Authorization": "Bearer tmw_live_xxxxxxxxxxxxxxxx"
      }
    }
  }
}

Save the file and restart Claude Desktop. You'll see a connect confirmation, and Temway tools become available to Claude for the workspace that key belongs to.

Connect claude.ai or ChatGPT on the web

Hosted web clients like claude.ai and ChatGPT don't accept static API keys for custom connectors — they walk you through a standard OAuth sign-in instead. You only need the Temway MCP URL; the client handles the rest.

Connector URL — same for both Claude and ChatGPT, with no header or key:

https://mcp.temway.com/mcp

In your AI client, open the connector / custom-connector settings and add a new connector with the URL above. Don't add any header or key.
The client opens a Temway authorization page. Sign in with your Temway account (Google) if you aren't already.
Pick the workspace the connector may access, review the permissions, and select Authorize.
You're sent back to claude.ai or ChatGPT, and the connector is live for your conversations.

The connection is bound to the workspace you picked, so it only ever sees that workspace's emails and layouts. To point it at a different workspace, remove the connector and add it again, choosing the other workspace during authorization. You can reuse the same connector across every chat.

Note: If your client still asks for an Authorization header (most desktop and CLI clients do), use the API key flow instead.

What you can ask

Once connected, just talk to Claude naturally. A few examples to get you started — mix and match to fit your workflow.

Start a new email

"Create a new email called June Newsletter."
"Start a new email from my branding."
"Make a promo email using the promo template."
"Create an email from my Newsletter layout."

Edit content and design

"Add a button that says Shop now linking to temway.com."
"Change the headline to Summer Sale and use our brand color."
"Swap the hero image for [URL]."
"Add a social block with our Facebook, Instagram, and X profiles."
"Apply our brand fonts across the whole email."

Preview and publish

"Show me a preview."
"Publish it."
"Send a test to [email protected]."

Build and reuse layouts

"Create a two-column layout I can reuse."
"Add a rounded rectangle behind the logo."
"Publish this layout so I can start new emails from it."

Full capabilities

These are the tools Claude can call on your behalf. You don't need to memorize them — describe what you want, and Claude picks the right one. They're listed here so you know exactly what the connection enables. Read actions need a read scope; anything that changes content needs a write scope.

Discovery & context

Let Claude understand your workspace and the available building blocks before it starts editing.

Tool	What it does
`get_branding`	Read your workspace branding — colors, fonts, logo, sender defaults
`list_block_types`	List the block types available in emails (text, button, image…)
`get_block_schema`	Get the editable properties of a block type
`list_layout_element_types`	List element types for layouts (image, text, button, shape, divider)
`get_element_schema`	Get the editable properties of a layout element
`get_universal_schema`	Get the brand-level (universal) settings for an email
`list_fonts`	List available fonts (email-safe, or all including Google and workspace custom for layouts)
`list_templates`	List email starter templates
`list_layout_templates`	List layout starter templates
`list_concepts`	List reusable concept scaffolds (composable content building blocks)
`get_concept`	Get the details of one concept

Emails

Tool	What it does
`list_emails`	List the emails in the workspace
`get_email`	Read one email (metadata or full content)
`create_email`	Create a new draft email
`update_email`	Update an email's name, subject, preheader, tags, or content
`delete_email`	Delete an email
`duplicate_email`	Duplicate an email
`create_email_from_layout`	Create a new email seeded from a published layout
`set_content`	Replace the entire content of an email (advanced)
`validate_content`	Validate an email's content against the schema

Email blocks

The natural way to edit an email — add, change, remove, or reorder individual blocks.

Tool	What it does
`add_block`	Add a new block (text, button, image, divider…)
`update_block`	Update a single block's properties
`remove_block`	Remove a block
`move_block`	Reorder a block within the email
`set_universal`	Apply brand-level settings across the whole email (colors, fonts)
`apply_template`	Apply a starter template to the email

Preview, publish & send

These run a quick render in the background and report back. Publish stores the version people see in shared links; test send delivers the inbox version to an email address.

Tool	What it does
`preview_email_web`	Render a fast, accurate web preview (the preferred preview)
`preview_email_html`	Render the inbox/HTML version to verify how it lands in email clients
`publish_email`	Render and publish the email (web version, with a saved version snapshot)
`test_send_email`	Send a test email to an address you specify

Layouts

Layouts are reusable canvases you can base new emails on. Publish a layout once, then start emails from it.

Tool	What it does
`list_layouts`	List the layouts in the workspace
`get_layout`	Read one layout
`create_layout`	Create a new draft layout
`update_layout`	Update a layout's name, description, or content
`delete_layout`	Delete a layout
`set_layout_content`	Replace the entire layout content (advanced)
`apply_layout_template`	Apply a starter layout template
`add_layout_element`	Add an element to the canvas (text, image, button…)
`add_custom_shape`	Add a custom SVG shape (bespoke vector artwork)
`update_layout_element`	Update an element's properties
`remove_layout_element`	Remove an element
`publish_layout`	Publish a layout so new emails can be created from it

When someone is editing in the browser

Temway keeps a lightweight edit lock on an email or layout while someone has it open in the browser, so two people don't overwrite each other's changes. If you ask Claude to edit something a teammate is currently editing, it will tell you who holds the lock rather than silently taking over.

If you're sure you want to proceed anyway (for example, a lock was left behind by a closed tab), Claude can force-release the lock — but it is wired to ask you for confirmation first, because forcing a release can lose the other person's unsaved work. The same protection works in reverse: someone in the browser can take over a lock Claude holds.

Tool	What it does
`acquire_email_lock` / `acquire_layout_lock`	Take the edit lock
`release_email_lock` / `release_layout_lock`	Release a lock you hold
`force_release_email_lock` / `force_release_layout_lock`	Force-release someone else's lock (Claude asks before doing this)