Seatable

SeaTable MCP

The official Model Context Protocol (MCP) server for SeaTable, built and maintained by SeaTable GmbH. It lets AI agents interact with data in your bases — reading, writing, searching, linking, and querying rows through a focused set of tools. The server intentionally focuses on data operations, not schema management (creating/deleting tables or columns), keeping the tool set lean and safe for autonomous agent use.

Quick Start

The fastest way to get started depends on your setup:

• SeaTable Cloud — Use the hosted MCP server at mcp.seatable.com, no installation needed
• Self-hosted SeaTable — Run the MCP server locally via npx in your IDE

SeaTable Cloud (hosted MCP server)

If you use SeaTable Cloud, there is a hosted MCP server ready to use — no installation required. Configure your MCP client with the Streamable HTTP endpoint:

Claude Desktop — add to claude_desktop_config.json:

{

"mcpServers": { "seatable": { "type": "streamable-http", "url": "https://mcp.seatable.com/mcp", "headers": { "Authorization": "Bearer your-api-token" } } } }

Cursor / VSCode — add to your MCP settings (JSON):

{

"mcp.servers": { "seatable": { "type": "streamable-http", "url": "https://mcp.seatable.com/mcp", "headers": { "Authorization": "Bearer your-api-token" } } } }

ChatGPT and other OAuth-compatible clients — use the built-in OAuth flow. In ChatGPT's developer mode, configure:

• Server URL: https://mcp.seatable.com/mcp
• Auth type: OAuth
• Authorization URL: https://mcp.seatable.com/authorize
• Token URL: https://mcp.seatable.com/token

You will be prompted to enter your SeaTable API token during the authorization step.

Self-hosted SeaTable

For self-hosted SeaTable instances, run the MCP server locally via npx. Your IDE starts and manages the process automatically.

Claude Desktop — add to claude_desktop_config.json:

{

"mcpServers": { "seatable": { "command": "npx", "args": ["-y", "@seatable/mcp-seatable"], "env": { "SEATABLE_SERVER_URL": "https://your-seatable-server.com", "SEATABLE_API_TOKEN": "your-api-token" } } } }

Cursor / VSCode — add to your MCP settings (JSON):

{

"mcp.servers": { "seatable": { "command": "npx", "args": ["-y", "@seatable/mcp-seatable"], "env": { "SEATABLE_SERVER_URL": "https://your-seatable-server.com", "SEATABLE_API_TOKEN": "your-api-token" } } } }

Deployment Options

If you need to run your own server instance — for example on your own infrastructure, with multi-base support, or in multi-tenant mode — use one of the options below.

HTTP Server (Network Access)

Run a local HTTP server with Streamable HTTP transport:

PORT=3001 npx -y @seatable/mcp-seatable --sse

Health check

curl http://localhost:3001/health

MCP endpoint: POST/GET/DELETE http://localhost:3001/mcp

Multi-Base (Selfhosted)

Serve multiple bases from a single process:

SEATABLE_SERVER_URL=https://your-seatable-server.com \

SEATABLE_BASES='[{"base_name":"CRM","api_token":"token_abc"},{"base_name":"Projects","api_token":"token_def"}]' \ npx -y @seatable/mcp-seatable

Each tool automatically gets a base parameter. Use list_bases to see available bases.

Managed Mode (Multi-Tenant HTTP)

For hosting an MCP endpoint where each client authenticates with their own SeaTable API token:

SEATABLE_MODE=managed \

SEATABLE_SERVER_URL=https://your-seatable-server.com \ SEATABLE_TOKEN_SECRET=$(openssl rand -hex 32) \ PORT=3000 npx -y @seatable/mcp-seatable --sse

SEATABLE_TOKEN_SECRET is required in managed mode. It seals the OAuth tokens the server issues, so the underlying SeaTable API token never has to be handed to a client. Keep it stable across restarts — changing it invalidates every issued access and refresh token and forces all clients to re-authorize.

Clients pass their credential via Authorization: Bearer — on session initialization and on every subsequent request, including GET and DELETE. The mcp-session-id header is a routing value only; it is never accepted on its own. Each request is re-validated and must resolve to the same identity that created the session, otherwise the server answers 401 (missing/invalid credential) or 403 (valid credential, wrong session). Rate limits apply as before (60 req/min per token, 120/min per IP, 20 concurrent connections per token).

OAuth support: Managed mode also exposes OAuth 2.0 endpoints (/authorize and /token), enabling OAuth-compatible clients like ChatGPT to connect — no external OAuth provider required. During the flow the user enters their SeaTable API token; the server seals it into its own short-lived access token (1 h) and a rotating refresh token (14 d). The raw SeaTable API token is never returned to a client.

Clients must register at /register first: the returned client_id carries the client's name and its redirect_uris, and the server accepts a callback only if it is one the client registered (loopback callbacks may vary the port, per RFC 8252). PKCE with S256 is mandatory, and every authorization code is bound to the client, the exact callback and the challenge.

Where a code may be delivered. With open dynamic registration, "registered client" is not a trust statement — anyone can register. What matters is whether the code leaves the user's machine:

The confirmation cannot be skipped from the entry link: it is read from the form body only, and a POST auto-submitted by a foreign page is refused via Sec-Fetch-Site. The trusted-host list therefore removes friction — it is not a gate, and leaving it unset breaks nothing.

The consent screen leads with the destination the authorization will be sent to. The application's name is shown as self-reported, because with open registration it is chosen by whoever registered the client and cannot be verified.

The OAuth endpoints are rate limited per IP (30/min overall, 10/min for token submissions), so /authorize cannot be used as an unthrottled oracle for testing SeaTable API tokens.

OAuth endpoints follow the MCP specification (RFC 8414 metadata discovery, PKCE, dynamic client registration):

Client ID and secret are not validated — dynamic client registration generates one automatically.

Docker

docker run -d --name seatable-mcp \

-p 3000:3000 \ -e SEATABLE_SERVER_URL=https://your-seatable-server.com \ -e SEATABLE_API_TOKEN=your-api-token \ seatable/seatable-mcp:latest

Health check

curl http://localhost:3000/health

Container hardening

The image is built so that code running inside the server process — for example through a vulnerable dependency — can't change the filesystem, start other programs or escalate privileges:

• Non-root: the server runs as node (uid 1000). The code in /app is owned by root and read-only for that user.
• Node permission model: the default CMD starts node --permission --allow-fs-read=/app. The process may read its own code and nothing else; writing files, child processes (no shell), worker threads and native addons are denied. Outbound network access is not affected. The server needs none of the denied operations, including download_file, which extracts PDF text in memory.
• No tools for an attacker: npm, npx, yarn, corepack and apk are removed, and so are busybox wget, nc and su. The health check uses node. There are no setuid binaries. Only apk's package list in /lib/apk/db stays, so that vulnerability scanners can see the OS packages. Without /sbin/apk it can't install anything, and the permission model denies the server read access to it.
• Pinned base image: node:22.23.4-alpine3.24 (build argument NODE_IMAGE), with apk upgrade at build time.

At runtime, add the restrictions the image can't set itself. docker-compose.yml contains all of them:

docker run -d --name seatable-mcp \

-p 3000:3000 \ --read-only --tmpfs /tmp:size=16m,noexec,nosuid,nodev \ --cap-drop ALL --security-opt no-new-privileges:true \ --pids-limit 128 --memory 512m \ -e SEATABLE_SERVER_URL=https://your-seatable-server.com \ -e SEATABLE_API_TOKEN=your-api-token \ seatable/seatable-mcp:latest

If you override the command (e.g. docker run … seatable/seatable-mcp node dist/index.js --sse), keep --permission --allow-fs-read=/app, otherwise the permission model is off.

OpenAI Secure MCP Tunnel

To use the server from ChatGPT without exposing it to the internet, run it next to OpenAI's tunnel-client. Setup and limitations: docs/openai-tunnel.md.

Security Model

The security characteristics differ significantly between transport modes:

⚠️ Warning: Selfhosted HTTP mode (--sse / --http) has no authentication. Anyone who can reach the port gets full access to all configured bases, including write and delete operations. Only run it in trusted networks (localhost, Docker-internal) or behind a reverse proxy that handles authentication. For untrusted networks, use managed mode instead.

Rate Limiting

SeaTable's own API gateway enforces rate limits per base (default: 500 requests/minute per base_uuid) and per organization (monthly quota). These limits apply regardless of whether requests come from the MCP server, the web UI, or direct API calls. The MCP server does not duplicate these limits — instead, it retries automatically with exponential backoff when SeaTable returns 429 Too Many Requests.

In managed mode, the MCP server adds its own rate limits to protect the server process itself (not the SeaTable backend): 60 req/min per token, 120/min per IP, 30/min for new session creation, and 20 concurrent connections per token.

Input Validation

All tool inputs are validated with Zod schemas before execution. Write tools (add_row, append_rows, update_rows, upsert_rows) additionally validate row data against the table schema — unknown columns are rejected, and read-only columns (formula, auto-number, creator, etc.) are stripped with a note in the response.

Tool schemas are published with additionalProperties: true to remain compatible with MCP clients that may attach internal fields (e.g. _meta). Unexpected fields are ignored by the server — they do not cause errors but are not processed either. This is a deliberate trade-off: stricter validation would improve error messages for typo