Temway MCP Server

Let your AI assistant design beautiful emails & layouts — in your Temway workspace.

A Model Context Protocol server that turns Claude, ChatGPT, Cursor and friends into a visual email & layout authoring studio.

MCP License: MIT Status

Getting Started · Clients · Tools · Temway

Temway is a visual builder for emails and layouts. This MCP server exposes your Temway workspace to any MCP-compatible AI client: the model reads your brand tokens, drafts a promo / newsletter / welcome email, previews it, publishes it, and even sends a test — all through natural language. No code, no drag-and-drop, no copy-pasting HTML.

It is a hosted remote MCP server. You point your client at a URL with an API key (or OAuth for web clients) — there is nothing to install, build, or run locally. The server speaks the MCP Streamable HTTP transport.

🔒 No source here? Correct. This is the public onboarding repo for the Temway MCP server. The server is operated by Temway and runs at https://mcp.temway.com/mcp. This repo holds client configuration, tool reference, and connectivity helpers. Report issues / request tools in Issues.

How it works

Your AI client (Claude / ChatGPT / Cursor / Desktop)
  └─ MCP over HTTPS  →  https://mcp.temway.com/mcp
                         Authorization: Bearer tmw_live_…   ← API key
                         (or OAuth token for web connectors)
                              └─ Temway public API  →  your workspace

The model authenticates per-request, then drives your workspace through brand-aware templates, block mutations, layout artwork, live previews, and publishing.

Getting started

1. Get an API key

API keys are minted by a team admin in the Temway dashboard. The key:

starts with tmw_live_…
is bound to one workspace
carries scopes (emails:read, emails:write, layouts:read, layouts:write) that gate which tools succeed

Store it securely — it's shown once.

2. Point your client at the server

The endpoint and a ready-to-paste config for each client are in examples/. The short version:

# Claude Code
claude mcp add --transport http temway https://mcp.temway.com/mcp \
  --header "Authorization: Bearer tmw_live_xxxxxxxxxxxxxxxx"

That's it. The workspace is derived from the key.

3. Ask your assistant

"Create a promo email for our summer sale, 25% off, brand colors, a big CTA button, preview it, then publish it."

The model will get_branding → create_email → apply_template → update_block → preview_email_web → publish_email for you.

Configure your client

The Temway server speaks the Streamable HTTP transport. Pick your client:

Client	Config	File
Claude Code	`claude mcp add --transport http …`	`examples/claude-code.md`
Claude Desktop	`mcpServers` JSON	`examples/claude-desktop.json`
claude.ai (web)	OAuth connector URL	`examples/claude-ai-web.md`
ChatGPT	OAuth connector URL	`examples/chatgpt.md`
Cursor	MCP settings	`examples/cursor.md`
Any MCP client	Streamable HTTP URL	`examples/generic.json`

Authentication

Two credential types — both resolve onto the same workspace context:

tmw_live_… API keys — for desktop & programmatic clients (Claude Code, Claude Desktop, Cursor, scripts). Sent as Authorization: Bearer tmw_live_…. The workspace is derived from the key. Scope-bound.
OAuth 2.1 — for hosted web connectors (claude.ai, ChatGPT) that reject static keys. No header to paste — the user signs in and picks a workspace on the consent screen; the connector receives its own short-lived token (PKCE / S256). Just enter the URL https://mcp.temway.com/mcp.

Tools

The server exposes 58 tools across five groups. Reads need a *:read scope; mutations need *:write.

Tool	What it does
`get_branding`	Fetch workspace brand tokens (colors, fonts, logo, socials, footer).
`list_block_types` / `get_block_schema`	Email block catalog + per-block editable fields.
`list_layout_element_types` / `get_element_schema`	Layout element catalog + fields.
`get_universal_schema`	Global email style fields.
`list_templates`	Curated email starter templates.
`list_fonts`	Usable fonts (web-safe for emails; + Google/custom for layouts).
`list_concepts` / `get_concept`	Mental-model concept docs (read before authoring).
`list_layout_templates`	Curated layout artwork starters.
`list_shape_presets` / `list_style_presets`	Decorative SVG library + style keys.

Tool	What it does
`list_emails` / `get_email`	Browse & read published/draft emails.
`create_email` / `update_email` / `delete_email` / `duplicate_email`	CRUD.
`create_email_from_layout`	Seed an email from a published layout.
`set_content` / `validate_content`	Replace whole content / validate before saving.
`add_block` / `update_block` / `remove_block` / `move_block`	Incremental block edits.
`set_universal`	Merge global email styles.
`apply_template`	Apply a brand-aware starter template.
`preview_email_web`	Fast web-target preview (preferred while iterating).
`preview_email_html`	Inbox-target MJML HTML (slower; verifies client rendering).
`publish_email`	Render + store; marks the email published.
`test_send_email`	Send a one-off test copy to an address.

Tool	What it does
`list_layouts` / `get_layout`	Browse & read layouts.
`create_layout` / `update_layout` / `delete_layout` / `duplicate_layout`	CRUD.
`set_layout_content`	Replace the whole layout descriptor.
`add_layout_element` / `update_layout_element` / `remove_layout_element`	Element edits (absolute positioning).
`add_custom_shape` / `add_shape_preset`	Bespoke SVG or curated decorative shapes.
`apply_layout_template`	Apply a layout starter (hero-banner, promo-card, …).
`fit_canvas_to_content`	Tighten canvas bounds to visible elements.
`publish_layout`	Snapshot for embedding in emails.

Note: layouts rasterize to a single PNG when embedded in an email (text not selectable). Author readable/clickable content as email blocks instead.

acquire_* / get_*_lock_status / refresh_*_lock / release_*_lock / force_release_*_lock for both email and layout resources.

Block/element mutations are not atomic — never fire two on the same resource in parallel. Acquire the edit-lock first on shared resources.

Tool	What it does
`search`	Search the workspace for emails/layouts by name/subject/tags.
`fetch`	Fetch the full content of a search result by id.

A typical authoring flow

get_branding
→ create_email { name: "Spring sale" }
→ apply_template { template: "promo" }        # brand-aware starter
→ update_block / add_block                    # tweak copy, CTA, colors
→ preview_email_web                           # fast preview (preferred)
→ publish_email                               # renders + marks published
→ test_send_email { to: "me@example.com" }    # optional real send

Environment variables

The hosted endpoint is fully managed — most users never touch env vars. They only matter if you self-host or run the stdio transport.

Var	Purpose	Required?
`TEMWAY_API_URL`	Temway API base URL.	Only when self-hosting.
`TEMWAY_API_KEY`	`tmw_live_…` key (stdio transport).	stdio only.
`TEMWAY_WORKSPACE_ID`	Workspace id (stdio transport; HTTP derives from key).	stdio only.
`LOG_LEVEL`	pino log level (default `info`).	no

Connectivity check

Verify the endpoint is reachable from your network before wiring up a client:

node scripts/healthcheck.mjs
# → OK 200 OK (926ms)
# → ✓ Temway MCP endpoint is reachable.

(npx temway-mcp-healthcheck once published, or npm run healthcheck.)

Self-hosting

This repo does not contain server source. If you need to run the server yourself (on-prem, air-gapped, custom auth), contact hi@temway.com or open an issue.

FAQ

The server is operated by Temway (source currently private). This repo is the public integration surface: client configs, tool reference, and helpers, published under the MIT license so you can copy configs freely.

No. The hosted remote transport means your client connects over HTTPS by URL — nothing runs locally. The optional healthcheck.mjs needs Node ≥ 18.17.

For local/CLI work: Claude Code or Cursor. For no-install browser use: claude.ai or ChatGPT with the OAuth connector. All configs are in examples/.

Credentials are scope-bound per key (*:read / *:write). Reads never mutate; every mutation is explicit. Narrow scopes to a read-only key for safe browsing.