# Jotform MCP: MCP Apps › Form Backend

The Jotform MCP server, built on the open Model Context Protocol, enables AI-powered, natural language access to forms and submissions.

> Markdown version of https://www.jotform.com/developers/mcp/?tab=mcp-app. Other pages: [Overview](https://www.jotform.com/developers/mcp/?format=md), [MCP](https://www.jotform.com/developers/mcp/?tab=mcp&format=md), [MCP Apps](https://www.jotform.com/developers/mcp/?tab=mcp-app&format=md).

# Form Backend

## Overview

Form Backend connects an existing website form to Jotform through your AI assistant. It creates a backing form in your Jotform account, collects responses, and configures owner notifications and visitor confirmation emails. Your website keeps its own form and design; no Jotform embed is required.

These tools return structured data without an embedded UI. Set up each website form once with `create_form_backend`, then reuse its `form_id`, `submit_url`, `submission_key`, and `field_mapping`. Calling the creation tool again creates another backing form.

## Available tools

| Tool | Description | Result |
| --- | --- | --- |
| Create Form Backend (`create_form_backend`) | Creates a backing Jotform form from your website's field names, labels, types, required flags, and choices. | Returns the form ID, public submission URL, signed submission key, and field mapping. |
| Update Form Backend (`update_form_backend`) | Updates the backing form using its form ID, current submission key, and the complete updated field list. Omitted fields are removed. | Returns the updated mapping and key. Replace the website's key when `submission_key_changed` is true, and review affected email templates. |
| List Form Responses (`list_form_responses`) | Lists up to 1000 recent responses for a backing form the connected user has permission to read. | Returns answers and form metadata in `data.submission_groups`. This is a recent listing, not a paginated export. |
| Configure Response Emails (`configure_response_emails`) | Configures owner notifications, visitor autoresponses, or both for future submissions. Visitor replies require an email field from the field mapping. | Returns the email configuration. Message inputs are plain text; the tool does not send an email immediately. |
| Update Response Email (`update_response_email`) | Edits an existing owner notification or visitor autoresponder: subject, HTML body, appended HTML, or email field. | Updates future emails. Use real HTML with inline CSS and `{q_2}` answer placeholders; use either a replacement body or appended HTML. |

After changing website fields, keep existing field names to retain their question IDs. Use `response_emails_to_review` from `update_form_backend` to update affected templates with `update_response_email`. If a visitor autoresponder was disabled because its email field changed, configure it again with `configure_response_emails`.

## Requirements

Form Backend builds on the [standard MCP requirements](https://www.jotform.com/developers/mcp/?tab=mcp#requirements). To get started you need:

1. A Jotform account and OAuth approval through your MCP connection.
2. An MCP-capable AI client and an existing website form whose submit handler you can edit.
3. Supported fields: text, email, number, textarea, select, radio, and checkbox. File uploads and payment fields are not supported.

The public website uses the returned submission key to write responses to that form only. It cannot read submissions or access your Jotform account. Keep Jotform API keys, OAuth tokens, and other secrets out of website code and form fields.

## Connect

| Setting | Value |
| --- | --- |
| Endpoint | `https://mcp.jotform.com/form-backend` |
| Transport | Streamable HTTP |
| Authentication | OAuth 2.0 authorization code flow with PKCE (`S256`). Each user approves access once on the Jotform consent screen. Jotform API keys are not accepted. |
| Authorization server | `https://oauth2.jotform.com`, advertised in the protected resource metadata at `https://mcp.jotform.com/.well-known/oauth-protected-resource/form-backend` |
| Scopes | `readOnly`, `full` |
| Client registration | Dynamic client registration is supported, so no client ID or secret is needed. |
| Interactive UI | Rendered in clients that support MCP Apps, such as Claude and ChatGPT. In other clients, tools return their results without the interface. |

### Add to your client

#### ChatGPT

**ChatGPT**

Turn on developer mode, then create an app with this server URL, choose OAuth, and approve access. Developer mode requires a paid plan, and on Business and Enterprise workspaces an admin must allow it.

```text
https://mcp.jotform.com/form-backend
```

ChatGPT developer mode guide: <https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt>

**Codex**

Run this command. Codex adds the server to `~/.codex/config.toml` and starts the sign-in; run `codex mcp login form-backend` if you need to sign in again.

```bash
codex mcp add form-backend --url https://mcp.jotform.com/form-backend
```

#### Claude

**Claude**

Open Settings → Connectors, choose Add custom connector, and enter this server URL. Then connect and approve access.

```text
https://mcp.jotform.com/form-backend
```

**Claude Code**

Run this command, then run `/mcp` in Claude Code and select the server to sign in.

```bash
claude mcp add --transport http form-backend https://mcp.jotform.com/form-backend
```

#### Cursor

Add the server to `~/.cursor/mcp.json` for all projects or `.cursor/mcp.json` for one project. Then open the MCP section of Cursor Settings, connect the server, and approve access in your browser.

```json
{
  "mcpServers": {
    "form-backend": {
      "url": "https://mcp.jotform.com/form-backend"
    }
  }
}
```

Add to Cursor: <cursor://anysphere.cursor-deeplink/mcp/install?name=form-backend&config=eyJ1cmwiOiJodHRwczovL21jcC5qb3Rmb3JtLmNvbS9mb3JtLWJhY2tlbmQifQ%3D%3D>

#### VS Code

Add the server to `.vscode/mcp.json` in your workspace, or run `MCP: Add Server` from the Command Palette and enter the server URL. Start the server and approve access when VS Code asks you to sign in.

```json
{
  "servers": {
    "form-backend": {
      "type": "http",
      "url": "https://mcp.jotform.com/form-backend"
    }
  }
}
```

Add to VS Code: <vscode:mcp/install?%7B%22name%22%3A%22form-backend%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.jotform.com%2Fform-backend%22%7D>

#### Other clients

Clients that support remote servers over Streamable HTTP with OAuth only need the server URL. Clients that can only run local (stdio) servers can connect through the `mcp-remote` bridge:

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

### Set up with your agent

Paste this prompt into an agent that can edit its own MCP configuration, such as Cursor, Claude Code, or Codex.

```text
Set up the Form Backend in this MCP client.
- Server URL: https://mcp.jotform.com/form-backend
- Transport: Streamable HTTP
- Authentication: OAuth 2.0 with dynamic client registration. Do not ask me for an API key; I will approve access in the browser when the client asks me to sign in.
- Documentation: https://www.jotform.com/developers/mcp/?tab=mcp-app&panel=form-backend&format=md
Add the server to this client's MCP configuration under the name "form-backend", start the sign-in, then list the available tools to confirm the connection.
```

## OAuth connections

When you add the Jotform MCP server to a client, the client opens an OAuth consent screen that lets you authorize the connection to your Jotform data. OAuth runs through a **Jotform App** and is required for every user the first time they connect. Only workspace admins can install the Jotform MCP app.

### View authorized MCP clients

1. Sign in to the Jotform Dashboard.
2. Go to **My Account** → **Connected Apps**.
3. Select **Jotform MCP**.
4. In the right panel, choose **Clients** to see all OAuth‑connected MCP clients.

### Revoke OAuth access for a specific client

1. In the Clients list, find the client you want to remove.
2. Click the overflow menu (⋮) next to its entry.
3. Select Revoke. The client loses access immediately.

Bearer‑token access is not supported; OAuth 2.0 is required for all connections.

## Usage Examples

Ask your assistant:

- “Connect my website's contact form to Jotform using its name, email, and message fields.” *(create_form_backend)*
- “Add a required topic dropdown to this website form and update its Jotform backend.” *(update_form_backend)*
- “Show the latest responses collected by my website's contact form.” *(list_form_responses)*
- “Notify me and send the visitor a confirmation after each submission.” *(configure_response_emails)*
- “Add a styled thank-you message to the visitor confirmation email.” *(update_response_email)*

After setup, have your assistant connect the website's submit handler to the returned `submit_url`. Send a JSON `POST` with `Content-Type: application/json`, the returned `submission_key`, and a `data` object whose keys exactly match the website field names in `field_mapping`. Send checkbox groups as arrays of strings or a single checkbox as a boolean.

Check that the response has `responseCode: 200` and `content.success: true` before displaying a success message. Email setup and edits apply to future submissions; they do not send a message immediately.
