# FoxForm (remote · mcp.foxform.app)

Build, publish and read scored forms and quizzes where the score picks the next screen.

- Trust score: 85/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- remote · `mcp.foxform.app`: 85/100 (this document), [markdown](https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp.md), [page](https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp)

## Channel facts

- Endpoint: `https://mcp.foxform.app/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Endpoint Security**: 89/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
  - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3474 tokens (~347/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 77/100
  - Stability observed for 23 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 91/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 74% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the FoxForm MCP server?

FoxForm is a hosted endpoint at https://mcp.foxform.app/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http vitorrocha-panda-foxform 'https://mcp.foxform.app/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "vitorrocha-panda-foxform": {
      "url": "https://mcp.foxform.app/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "vitorrocha-panda-foxform": {
      "type": "http",
      "url": "https://mcp.foxform.app/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.vitorrocha-panda-foxform]
url = "https://mcp.foxform.app/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "vitorrocha-panda-foxform": {
      "type": "remote",
      "url": "https://mcp.foxform.app/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add vitorrocha-panda-foxform --url 'https://mcp.foxform.app/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  vitorrocha-panda-foxform:
    url: "https://mcp.foxform.app/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "vitorrocha-panda-foxform": {
      "Transport": "http",
      "Url": "https://mcp.foxform.app/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add vitorrocha-panda-foxform -t streamable-http -u 'https://mcp.foxform.app/mcp'
```

### Other

```json
{
  "mcpServers": {
    "vitorrocha-panda-foxform": {
      "type": "http",
      "url": "https://mcp.foxform.app/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-20 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 70 to 73. That category is still filling its 30-day observation window: 21 days of observed history at the previous scan, 22 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-18 (score 84, +1)

No change was recorded against any check on this day. Stability & Change Management went from 63 to 67. That category is still filling its 30-day observation window: 19 days of observed history at the previous scan, 20 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-15 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-13 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-11 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-09 (score 80, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-07 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-05 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (10)

### `foxform_list_forms` (~248 tokens)

List FoxForm forms

List the forms owned by the authenticated FoxForm account, newest first.

Args:
  \- page (number): 1-based page number (default 1)
  \- limit (number): page size, 1-100 (default 20)
  \- response_format ('markdown' | 'json'): output format (default markdown)

Returns: { total, page, limit, count, forms: [{ id, title, status, slug, public_url, questions_count, updated_at }] }
The public link of a form is `public_url` (`https://forms.foxform.app/<slug>`) — always use this exact value, do NOT build the URL yourself (the public domain is forms.foxform.app, not foxform.app). `public_url` is only live when `status` is 'published'.
Use this first to discover form IDs, then call foxform_get_form / foxform_get_form_analytics.

Input parameters:

- `limit` (integer): Page size (1-100)
- `page` (integer): 1-based page number
- `response_format` (string): Output format: 'markdown' (human-readable) or 'json' (machine-readable)

### `foxform_get_form` (~837 tokens)

Get a FoxForm form

Fetch a single form by ID, including its full question list, per-screen conditional logic and settings.

Args:
  \- form_id (string): the form's ID (from foxform_list_forms)
  \- response_format ('markdown' | 'json')

Returns { form, public_url }: the full form object (id, title, description, slug, status, theme, questions[], thank_you_message, timestamps) plus `public_url` — the public link (`https://forms.foxform.app/<slug>`), which is live only when status is 'published'. Use `public_url` verbatim; never build the URL yourself (the public domain is forms.foxform.app, not foxform.app).
Each screen in `questions[]` carries its own `logic` (branching / conditional display) and, for choice screens, `choices[]`/`images[]` with their `points` and `value`. The markdown output summarises every rule; use response_format 'json' to get the exact stored objects (that's the shape foxform_update_form expects back).

CONDITIONAL LOGIC (branching), per screen — stored in `questions[].logic`:

  logic.conditionalNavigationV2 = {
    enabled: true,
    groups: [                       // groups are OR-joined; FIRST matching group wins
      {
        id: "grp-1",
        conditions: [               // conditions inside a group are AND-joined
          { id: "cond-1", left: "{{quer_testar}}", operator: "equal_to", right: "Ainda não" }
        ],
        then: { type: "specific_screen", targetScreenId: "s-motivos" }
      }
    ]
  }

\- `then.type`: 'next_screen' | 'previous_screen' | 'specific_screen' (needs targetScreenId = another screen's `id`) | 'end_form'.
  Add `then.url` (+ optional `openNewTab`) to redirect to an external URL instead.
\- `operator`: 'equal_to' | 'not_equal_to' | 'greater_than' | 'greater_or_equal_than' | 'less_than' | 'less_or_equal_than' | 'contains'.
\- `left`/`right` are EXPRESSION strings: a literal ("10", "Ainda não"), a variable ("{{score}}", "{{minha_var}}" = the screen's `variableName`), or arithmetic ("calc({{peso}}/(({{altura}}/100)*({{altura}}/100)))…

Input parameters:

- `form_id` (string, required): Form ID
- `response_format` (string): Output format: 'markdown' (human-readable) or 'json' (machine-readable)

### `foxform_list_responses` (~173 tokens)

List form responses

List submitted responses for a form, newest first.

Args:
  \- form_id (string): the form's ID
  \- page (number): 1-based page (default 1)
  \- limit (number): page size, 1-100 (default 20)
  \- response_format ('markdown' | 'json')

Returns: { total, page, limit, count, responses: [{ id, submitted_at, answers }] }.
For aggregate metrics use foxform_get_form_analytics; for a full dump use foxform_export_responses.

Input parameters:

- `form_id` (string, required): Form ID
- `limit` (integer)
- `page` (integer)
- `response_format` (string): Output format: 'markdown' (human-readable) or 'json' (machine-readable)

### `foxform_get_response` (~97 tokens)

Get a single response

Fetch one response by its ID (from foxform_list_responses).

Args:
  \- response_id (string)
  \- response_format ('markdown' | 'json')

Returns the full response object (id, form_id, answers, submitted_at, metadata).

Input parameters:

- `response_format` (string): Output format: 'markdown' (human-readable) or 'json' (machine-readable)
- `response_id` (string, required): Response ID

### `foxform_get_form_analytics` (~146 tokens)

Get form analytics

Aggregated analytics for a form: overview KPIs (total responses, form views, response rate, avg response time), the responses-over-time timeline, and per-question stats.

Args:
  \- form_id (string)
  \- response_format ('markdown' | 'json')

Returns: { overview, timeline: [{date,count}], questions: [...], response_time_distribution?, views_timeline? }.
Note: form_views / response_rate are null until the form has tracked views (forward-only).

Input parameters:

- `form_id` (string, required): Form ID
- `response_format` (string): Output format: 'markdown' (human-readable) or 'json' (machine-readable)

### `foxform_export_responses` (~73 tokens)

Export responses as CSV

Export all responses for a form as CSV text (one row per response, columns = questions). Large exports are truncated — use foxform_list_responses with pagination for very large datasets.

Args:
  \- form_id (string)

Returns: raw CSV text.

Input parameters:

- `form_id` (string, required): Form ID

### `foxform_create_form` (~839 tokens)

Create a FoxForm form

Create a new form, including per-screen conditional logic. Requires a WRITE-scoped API key.

Args:
  \- title (string): form title (required)
  \- description (string, optional)
  \- theme (string, optional): one of midnight|ocean|sunset|forest|lavender|minimal (default sunset = Ember)
  \- questions (array, optional): array of screen objects ({ id, type, title, required, variableName?, choices?, logic?, ... }); omit to start empty
  \- thank_you_message (string, optional)

Returns: { form } with the created form (including its id and slug). The form starts as a draft — call foxform_publish_form to make it live.

Screen fields are validated: unknown fields are REJECTED instead of being stored and ignored, and branching rules are cross-checked against the screen ids in the same payload.

CONDITIONAL LOGIC (branching), per screen — stored in `questions[].logic`:

  logic.conditionalNavigationV2 = {
    enabled: true,
    groups: [                       // groups are OR-joined; FIRST matching group wins
      {
        id: "grp-1",
        conditions: [               // conditions inside a group are AND-joined
          { id: "cond-1", left: "{{quer_testar}}", operator: "equal_to", right: "Ainda não" }
        ],
        then: { type: "specific_screen", targetScreenId: "s-motivos" }
      }
    ]
  }

\- `then.type`: 'next_screen' | 'previous_screen' | 'specific_screen' (needs targetScreenId = another screen's `id`) | 'end_form'.
  Add `then.url` (+ optional `openNewTab`) to redirect to an external URL instead.
\- `operator`: 'equal_to' | 'not_equal_to' | 'greater_than' | 'greater_or_equal_than' | 'less_than' | 'less_or_equal_than' | 'contains'.
\- `left`/`right` are EXPRESSION strings: a literal ("10", "Ainda não"), a variable ("{{score}}", "{{minha_var}}" = the screen's `variableName`), or arithmetic ("calc({{peso}}/(({{altura}}/100)*({{altura}}/100)))").
\- Comparing an ANSWER: use `left: "{{<variableName of the deciding screen>}}"` and `right` = the option's `label` OR its…

Input parameters:

- `description` (string): Optional description
- `questions` (array): Screen objects; omit for an empty form. Conditional logic goes in each screen's `logic` (see the tool description).
- `thank_you_message` (string)
- `theme` (string): Theme key (default sunset/Ember)
- `title` (string, required): Form title

### `foxform_update_form` (~861 tokens)

Update a FoxForm form

Update an existing form's fields, including each screen's conditional logic (branching). Requires a WRITE-scoped API key. Only the fields you pass are changed.

Args:
  \- form_id (string): the form to update (required)
  \- title (string, optional)
  \- description (string, optional)
  \- theme (string, optional)
  \- questions (array, optional): replaces the FULL screen list — there is no per-screen patch. To add logic to one screen: call foxform_get_form with response_format 'json', edit that screen's `logic`, and send the whole array back.
  \- thank_you_message (string, optional)

Returns: { form } with the updated form.

Screen fields are validated: unknown fields are REJECTED instead of being stored and ignored (the API accepts arbitrary keys but no renderer reads them), `then.targetScreenId` must be the id of a screen in the same payload, and `{{variables}}` that no screen exposes come back as warnings.

CONDITIONAL LOGIC (branching), per screen — stored in `questions[].logic`:

  logic.conditionalNavigationV2 = {
    enabled: true,
    groups: [                       // groups are OR-joined; FIRST matching group wins
      {
        id: "grp-1",
        conditions: [               // conditions inside a group are AND-joined
          { id: "cond-1", left: "{{quer_testar}}", operator: "equal_to", right: "Ainda não" }
        ],
        then: { type: "specific_screen", targetScreenId: "s-motivos" }
      }
    ]
  }

\- `then.type`: 'next_screen' | 'previous_screen' | 'specific_screen' (needs targetScreenId = another screen's `id`) | 'end_form'.
  Add `then.url` (+ optional `openNewTab`) to redirect to an external URL instead.
\- `operator`: 'equal_to' | 'not_equal_to' | 'greater_than' | 'greater_or_equal_than' | 'less_than' | 'less_or_equal_than' | 'contains'.
\- `left`/`right` are EXPRESSION strings: a literal ("10", "Ainda não"), a variable ("{{score}}", "{{minha_var}}" = the screen's `variableName`), or arithmetic ("calc({{peso}}/(({{altura}}/100)*({{altura}}/100…

Input parameters:

- `description` (string)
- `form_id` (string, required): Form ID
- `questions` (array): Replaces the full screen list. Conditional logic goes in each screen's `logic` (see the tool description).
- `thank_you_message` (string)
- `theme` (string)
- `title` (string)

### `foxform_publish_form` (~143 tokens)

Publish a form

Publish a form so it's live at its public URL and can accept responses. Requires a WRITE-scoped API key.

Args:
  \- form_id (string)

Returns: { form, public_url } — the published form (status 'published') and its live public link `https://forms.foxform.app/<slug>`. When sharing the link with the user, use `public_url` EXACTLY as returned; do NOT build the URL yourself (the public domain is forms.foxform.app, NOT foxform.app or the API/app domain). (May fail with a plan-limit error on Free accounts.)

Input parameters:

- `form_id` (string, required): Form ID

### `foxform_unpublish_form` (~57 tokens)

Unpublish a form

Unpublish a form (takes it offline; stops accepting responses). Requires a WRITE-scoped API key.

Args:
  \- form_id (string)

Returns: a confirmation message.

Input parameters:

- `form_id` (string, required): Form ID

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp#diagnostics

## Score history

- 2026-09-21: 85
- 2026-09-20: 85
- 2026-09-19: 84
- 2026-09-18: 84
- 2026-09-17: 83
- 2026-09-16: 83
- 2026-09-15: 83
- 2026-09-14: 82
- 2026-09-13: 82
- 2026-09-12: 81
- 2026-09-11: 81
- 2026-09-10: 80
- 2026-09-09: 80
- 2026-09-08: 79
- 2026-09-07: 79
- 2026-09-06: 78
- 2026-09-05: 78
- 2026-09-04: 77
- 2026-09-03: 77
- 2026-09-02: 74
- 2026-09-01: 74
- 2026-08-31: 73
- 2026-08-30: 73
- 2026-08-29: 72

## Common questions

### What is the FoxForm MCP server?

FoxForm is an MCP server listed in the public MCP registry as io.github.vitorrocha-panda/foxform. Build, publish and read scored forms and quizzes where the score picks the next screen. This page covers its hosted endpoint (https://mcp.foxform.app/mcp).

### Is the FoxForm MCP server safe to use?

FoxForm scores 85 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the FoxForm MCP server expose?

FoxForm exposes 10 tools: foxform_list_forms, foxform_get_form, foxform_list_responses, foxform_get_response, foxform_get_form_analytics, and 5 more. Their descriptions and schemas cost roughly 3,474 tokens of context every time the server is loaded.

### Does the FoxForm MCP server require authentication?

Yes. FoxForm asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the FoxForm MCP server still maintained?

FoxForm is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://mcp.foxform.app/mcp
- Authorisation metadata: https://mcp.foxform.app/.well-known/oauth-protected-resource/mcp
- Website: https://foxform.app/
- Changelog RSS feed: https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp.json
- HTML version of this page: https://verifymcp.io/servers/vitorrocha-panda-foxform/mcp