# Webflow

> Edit a live Webflow site from an agent — CMS collections, pages, and the Designer canvas over OAuth.

[Canonical HTML page](https://top-mcps.com/mcp/webflow) · [server.json](https://top-mcps.com/mcp/webflow.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Claude Desktop launches stdio servers, so mcp-remote bridges to the hosted endpoint and opens the sign-in in your browser. On Pro, Max, Team and Enterprise you can skip the file: Settings → Connectors → Add custom connector → https://mcp.webflow.com/sse. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```json
{
  "mcpServers": {
    "webflow": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.webflow.com/sse"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Then run /mcp inside Claude Code to finish the sign-in. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```shell
claude mcp add --transport sse webflow https://mcp.webflow.com/sse
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Cursor shows "Needs login" once it connects — click it to authorize. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```json
{
  "mcpServers": {
    "webflow": {
      "url": "https://mcp.webflow.com/sse"
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key. Run MCP: List Servers → Start Server and allow the sign-in. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```jsonc
{
  "servers": {
    "webflow": {
      "type": "sse",
      "url": "https://mcp.webflow.com/sse"
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Windsurf uses "serverUrl" for hosted servers. Open via Cascade → hammer icon → Configure. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```json
{
  "mcpServers": {
    "webflow": {
      "serverUrl": "https://mcp.webflow.com/sse"
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Bridged through mcp-remote. Open via the Cline sidebar → MCP Servers → Edit. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```json
{
  "mcpServers": {
    "webflow": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.webflow.com/sse"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue takes the hosted URL directly in the transport block. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "sse",
          "url": "https://mcp.webflow.com/sse"
        }
      }
    ]
  }
}
```

### Codex CLI — `CLI`

Codex detects OAuth support and opens the browser to authorize. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```shell
codex mcp add webflow --url https://mcp.webflow.com/sse
```

### Zed — `~/.config/zed/settings.json`

Bridged through mcp-remote under "context_servers". Settings live-reload on save. Authorization happens in the browser on first use (OAuth); no token goes in the config file.

```jsonc
{
  "context_servers": {
    "webflow": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "mcp-remote",
          "https://mcp.webflow.com/sse"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Settings → Connectors (remote URL)`

Paste this into Settings → Connectors → Add custom connector. Requires ChatGPT Pro / Team / Enterprise / Edu with Developer mode enabled.

```json
{
  "name": "Webflow",
  "transport": "http",
  "url": "https://mcp.webflow.com/sse"
}
```

## At a glance

- **Maintainer:** Webflow
- **Transport:** SSE, stdio
- **Auth model:** OAuth 2.1
- **Required secrets:** None
- **Supported clients:** Claude, Cursor, VS Code, Windsurf, Any MCP-compatible client, Webflow workspaces
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-09-17
- **GitHub stars:** 140 (fetched 2026-10-15T10:09:13.495Z)
- **Score:** 64/100 (rubric 2026-09 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/webflow/mcp-server
- **Homepage:** https://developers.webflow.com/data/docs/ai-tools

## Security & scope

- **Access scope:** read-write
- **Sandbox:** No sandbox. OAuth scopes are granted per site during authorization — authorize only the sites the agent should touch.
- **Gotchas:**
  - Publishing is a tool, not a review step. An agent that creates a CMS item and publishes it puts it on the live site immediately.
  - The Designer half only works while the Bridge App is open in the Webflow Designer; without it the canvas tools have nothing to talk to.
  - The local stdio path takes a `WEBFLOW_TOKEN` site API token, which is long-lived and not scoped per session — prefer the remote OAuth path.

## Quick answer

**What it does.** Exposes Webflow's Data API as MCP tools over a remote OAuth connection: list and read sites and pages, create and update CMS collection items, publish, and manage custom code. With the MCP Bridge App running in the Webflow Designer, the same connection reaches the canvas for element-level edits.

**Best for:**
- Drafting and publishing CMS collection items
- Element-level edits via the Designer bridge
- Content audits and internal linking across a site
- OAuth instead of a stored site token
- Agencies managing several Webflow sites

**Not for:**
- Non-Webflow sites
- Headless front ends that only need a content API
- Setups that cannot publish a Designer extension to the workspace

## Description

Webflow's official MCP server is remote and OAuth-authenticated at `https://mcp.webflow.com/sse`. It covers the Data API — sites, pages, CMS collections and items, custom code, publishing — and, uniquely in this category, it pairs with a Designer bridge app so an agent can also build and edit elements on the canvas rather than only the content behind it.

## Why it matters

Most CMS MCPs stop at the content record. Webflow's reaches the design surface, so "add a hero section with a CTA to the home page" is a tool call rather than a set of instructions for a human. The OAuth flow also means no long-lived site token sitting in a config file.

## Key features

- Official Webflow remote MCP with OAuth
- Designer bridge app for canvas edits
- Data API coverage: sites, pages, CMS, custom code
- Local stdio fallback via `webflow-mcp-server` and a site token
- Requires Node.js 22.3+ for the local path

## FAQ

### Remote or local?

Remote is the documented default: point the client at `https://mcp.webflow.com/sse` and authorize via OAuth. The local `webflow-mcp-server` package still exists and takes a `WEBFLOW_TOKEN`, but it requires you to register and publish your own Bridge App first.

### Can it actually design, or only edit content?

Both, but the design half has a prerequisite: the Webflow MCP Bridge App must be open in the Designer for the canvas tools to connect. Content tools work without it.

### Why is there no tool table here?

The server is remote and OAuth-gated, so it cannot be probed without a Webflow account. This directory lists tool names only when it has run the server and read them back — an absent table means "not yet verified," not "no tools".

## Changelog

- **2026-09-17** — Refreshed install snippets and fact sheet; verified for 2026.