> ## Documentation Index
> Fetch the complete documentation index at: https://apidocs.neetoform.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect your assistant

> Server details and per client setup for the NeetoForm MCP server.

## Server details

| Setting        | Value                                          |
| -------------- | ---------------------------------------------- |
| Endpoint       | `https://connect.neetoform.com/mcp/messages`   |
| Transport      | HTTP                                           |
| Authentication | OAuth, or `Authorization: Bearer YOUR_API_KEY` |

How you connect decides what the assistant can see, so pick the method before
the client. See [Authentication](/mcp/authentication) for what the two mean in
practice.

| Your assistant                                            | OAuth, scoped to you | API key, scoped to the workspace |
| --------------------------------------------------------- | -------------------- | -------------------------------- |
| Claude, ChatGPT                                           | Yes                  | Not supported                    |
| Claude Code, Codex, Cursor, Gemini CLI, VS Code, Windsurf | Yes                  | Yes                              |

Claude and ChatGPT only ever act as you. The editor and terminal clients support
both, and the difference is one line of config: leave the credential out and the
client signs you in over OAuth, supply one and the client reaches the whole
workspace.

## OAuth, scoped to you

Nothing to create in NeetoForm beforehand. You give the client the server URL and
approve the connection in the browser.

<Tabs>
  <Tab title="Claude">
    Custom connectors work on claude.ai, in the Claude desktop app, and in
    Cowork. The steps below are the same in all three, and a connector you add in
    one shows up in the others.

    1. Open **[Settings > Connectors](https://claude.ai/customize/connectors)**.

    2. Click **Add**, then **Add custom connector**.

    3. Give it a name and paste the server URL:

       ```
       https://connect.neetoform.com/mcp/messages
       ```

       Leave **Advanced settings** alone. The OAuth client id and secret there
       are for servers that cannot register clients on their own, and NeetoForm
       does that automatically.

    4. Click **Add**, then **Connect** to start the sign in.

    If connectors are managed centrally in your organization, an Owner adds it
    once under
    **[Organization settings > Connectors](https://claude.ai/admin-settings/connectors)**,
    after which everyone else connects from their own Connectors list.

    Anthropic documents the current steps in
    [Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp).
  </Tab>

  <Tab title="ChatGPT">
    Custom MCP servers are added through developer mode.

    1. Open **Settings → Security and login** and turn on **Developer mode**. The
       **Plugins** settings section links straight to it.

    2. Go to **Plugins**, click **Browse plugins**, then the **plus** button.

    3. In **New Plugin**, enter a name, set **Connection** to **Server URL**, and
       paste:

       ```
       https://connect.neetoform.com/mcp/messages
       ```

    4. Leave **Authentication** on **OAuth**. ChatGPT reads NeetoForm's OAuth
       settings from the URL, so **Advanced OAuth settings** needs nothing from
       you.

    5. Tick **I understand and want to continue**, then click **Create** and
       approve the NeetoForm sign in.

    OpenAI documents the current steps in
    [Building MCP servers for plugins and API integrations](https://developers.openai.com/api/docs/mcp).
    They renamed the app directory to the plugin directory in July 2026, so older
    walkthroughs may say "apps" or "connectors" where the UI now says "plugins".
  </Tab>

  <Tab title="Claude Code">
    Add the server without a header. The missing credential is what makes Claude
    Code sign you in rather than send a key.

    ```bash theme={"system"}
    claude mcp add --transport http neetoform https://connect.neetoform.com/mcp/messages
    ```

    Run `claude mcp list` and the server reads `Needs authentication`. Start
    Claude Code, run `/mcp`, pick **neetoform**, and complete the sign in in the
    browser.
  </Tab>

  <Tab title="Cursor">
    Add the server to `~/.cursor/mcp.json`, or to `.cursor/mcp.json` for a single
    project, with no `headers` block:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "url": "https://connect.neetoform.com/mcp/messages"
        }
      }
    }
    ```

    Restart Cursor, then approve the NeetoForm sign in when it prompts.
  </Tab>

  <Tab title="Gemini CLI">
    Add the server to `~/.gemini/settings.json`, or to `.gemini/settings.json`
    for a single project, with no `headers` block. Streamable HTTP servers go
    under `httpUrl`, not `url`, which Gemini CLI reserves for SSE:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "httpUrl": "https://connect.neetoform.com/mcp/messages"
        }
      }
    }
    ```

    Gemini CLI starts the sign in when the server answers with a 401 and
    registers itself automatically.
  </Tab>

  <Tab title="Codex">
    Codex uses TOML rather than JSON. Add the server to `~/.codex/config.toml`,
    or to `.codex/config.toml` for a single project, with no credential fields.
    OAuth is what Codex falls back to when none are given:

    ```toml theme={"system"}
    [mcp_servers.neetoform]
    url = "https://connect.neetoform.com/mcp/messages"
    ```

    Then start the sign in:

    ```bash theme={"system"}
    codex mcp login neetoform
    ```
  </Tab>

  <Tab title="VS Code">
    Create `.vscode/mcp.json` with no `headers` block. VS Code nests servers
    under `servers`, not `mcpServers`:

    ```json theme={"system"}
    {
      "servers": {
        "neetoform": {
          "type": "http",
          "url": "https://connect.neetoform.com/mcp/messages"
        }
      }
    }
    ```

    Needs VS Code 1.99 or later with GitHub Copilot in Agent mode. Approve the
    NeetoForm sign in when it prompts.
  </Tab>

  <Tab title="Windsurf">
    Add the server to `~/.codeium/windsurf/mcp_config.json` with no `headers`
    block. Windsurf uses `serverUrl` rather than `url`:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "serverUrl": "https://connect.neetoform.com/mcp/messages"
        }
      }
    }
    ```

    Enable the server under **Settings → Cascade → MCP Servers**, then approve
    the NeetoForm sign in when it prompts.
  </Tab>
</Tabs>

### What the sign in looks like

Whichever client you started from, NeetoForm runs the same steps.

<Steps>
  <Step title="Choose your workspace">
    Enter the subdomain of the workspace you want the assistant to reach. For
    `acme.neetoform.com`, enter `acme`. See
    [Workspace subdomain](/getting-started/workspace-subdomain).
  </Step>

  <Step title="Sign in">
    Sign in to that workspace if you are not signed in already.
  </Step>

  <Step title="Pick the workspaces to connect">
    **Workspaces to connect** lists every workspace your email belongs to. The
    one you just signed in to is ticked and cannot be unticked. Tick any others
    you want the same connection to reach.

    This section only appears when your email belongs to more than one
    workspace. With a single workspace, the screen goes straight to the details
    and the buttons.
  </Step>

  <Step title="Authorize">
    Click **Authorize**. The assistant is granted access as you, with your
    permissions, to each workspace you ticked.
  </Step>
</Steps>

There is no API key to create for this route, and nothing to paste back into the
assistant.

Once connected, name the workspace in a prompt when you want a specific one. To
add a workspace later, run the sign in again and tick it.

## API key, scoped to the workspace

The same six clients, configured with a key instead. Every tool call then reaches
the whole workspace rather than only what you can see, which is what you want for
automation and not what you want on a shared machine.

<Tabs>
  <Tab title="Claude Code">
    Add the server to `~/.claude.json` under `mcpServers`:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "type": "http",
          "url": "https://connect.neetoform.com/mcp/messages",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```

    Restart Claude Code after saving.
  </Tab>

  <Tab title="Cursor">
    Add the server to `~/.cursor/mcp.json` under `mcpServers`:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "url": "https://connect.neetoform.com/mcp/messages",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```

    Restart Cursor, or reload the window from the command palette.
  </Tab>

  <Tab title="Gemini CLI">
    Add the server to `~/.gemini/settings.json` under `mcpServers`. Streamable
    HTTP servers go under `httpUrl`, not `url`:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "httpUrl": "https://connect.neetoform.com/mcp/messages",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Codex">
    Codex uses TOML rather than JSON, and takes the name of an environment
    variable rather than the key itself, which keeps the key out of the file:

    ```toml theme={"system"}
    [mcp_servers.neetoform]
    url = "https://connect.neetoform.com/mcp/messages"
    bearer_token_env_var = "NEETOFORM_API_KEY"
    ```

    Export `NEETOFORM_API_KEY` in the environment Codex runs in.
  </Tab>

  <Tab title="VS Code">
    <Warning>
      Unlike the other clients, this config lives inside your project rather than
      your home directory, so a pasted key can end up in a commit. Add
      `.vscode/mcp.json` to `.gitignore` **before** you create the file.

      Better still, leave the key out of the file entirely: omit the `headers`
      block and VS Code signs you in over [OAuth](#oauth-scoped-to-you), which
      needs no secret in the project at all.
    </Warning>

    Once `.vscode/mcp.json` is ignored, create it in your workspace. VS Code
    nests servers under `servers`, not `mcpServers`:

    ```json theme={"system"}
    {
      "servers": {
        "neetoform": {
          "type": "http",
          "url": "https://connect.neetoform.com/mcp/messages",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```

    This needs VS Code 1.99 or later with GitHub Copilot in Agent mode. The
    editor prompts for your API key the first time the server is used.
  </Tab>

  <Tab title="Windsurf">
    Add the server to `~/.codeium/windsurf/mcp_config.json`. Windsurf uses
    `serverUrl` rather than `url`:

    ```json theme={"system"}
    {
      "mcpServers": {
        "neetoform": {
          "serverUrl": "https://connect.neetoform.com/mcp/messages",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```

    Enable the server under **Settings → Cascade → MCP Servers**. Windsurf allows
    at most 100 tools across every connected server, so disable servers you are
    not using if NeetoForm's tools do not appear.
  </Tab>
</Tabs>

Replace `YOUR_API_KEY` with a key from your workspace. See
[Authentication](/mcp/authentication).

## Confirm the connection

Ask the assistant something only the server can answer, for example
"List the active forms in my NeetoForm workspace." If it answers with real forms,
the connection works. If it does not, see [Troubleshooting](/mcp/troubleshooting).