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

# MCP

> Pipe Jam bug context into Claude, Cursor, VS Code, and other AI coding tools. Your agent goes from bug to fix without copy-pasting.

export const ToolHeader = () => <div style={{
  width: "14rem"
}}>Tool</div>;

export const InstallButton = ({href, children}) => <a className="not-prose inline-flex items-center h-8 px-3 rounded-md text-sm font-medium no-underline hover:opacity-90" style={{
  color: "var(--gray-1)",
  background: "var(--gray-12)"
}} href={href} target="_blank" rel="noopener noreferrer">
    {children}
  </a>;

<img src="https://mintcdn.com/jam-1eb4fd26/3Mtv5mLh0Dqadb4R/images/mcp-debug-panel.png?fit=max&auto=format&n=3Mtv5mLh0Dqadb4R&q=85&s=abf8f63c9ca8b57a5ea34feba86792a4" alt="AI agent debugging a Jam via MCP, with calls to getConsoleLogs, getNetworkRequests, and getUserEvents tools" width="1536" height="810" data-path="images/mcp-debug-panel.png" />

Jam MCP (Model Context Protocol) lets your AI coding tools open a Jam recording and automatically load its full context (video, user events, console logs, errors, and network requests) right where you're working. Paste a Jam link into any supported MCP client and the context flows directly to your agent.

Jam captures console logs, network requests, user events, and your chosen metadata automatically when you record. With MCP, that context flows into Claude Code, Cursor, VS Code, and Windsurf without copy-pasting.

## Prerequisites

You need a Jam recording before your agent can use MCP.

<Steps>
  <Step title="Install the Jam Chrome extension">
    Install the [Chrome
    extension](https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci)
    from the Chrome Web Store.
  </Step>

  <Step title="Record a Jam">
    Hit **Record** to capture your screen and voice.
  </Step>

  <Step title="Copy your Jam link">
    Stop the recording. Your Jam link is ready for an agent to consume via MCP.
  </Step>
</Steps>

## Step 1: Configure your MCP client

<Tabs>
  <Tab title="ChatGPT">
    <Card title="Jam plugin for ChatGPT">
      Install the plugin, then sign in to Jam and allow access to your workspace.

      <InstallButton href="https://chatgpt.com/plugins/plugin_connector_6923e677f37c8191845e4e0b658dd718">Install plugin</InstallButton>
    </Card>
  </Tab>

  <Tab title="Claude">
    <Card title="Jam connector for Claude">
      Install the connector, sign in to Jam and allow access to your workspace.

      <InstallButton href="https://claude.ai/directory/connectors/jam">Install connector</InstallButton>
    </Card>
  </Tab>

  <Tab title="Cursor">
    <Card title="Jam plugin for Cursor">
      Install the plugin from the Cursor Marketplace.

      <InstallButton href="https://cursor.com/marketplace/jam">Install plugin</InstallButton>
    </Card>
  </Tab>

  <Tab title="VS Code">
    <Steps>
      <Step title="Open the command palette">
        Press `Ctrl`/`Cmd` + `P` and enter `>MCP: Add Server`.
      </Step>

      <Step title="Select the transport type">
        Select **HTTP (HTTP or Server-Sent Events)**.
      </Step>

      <Step title="Enter the server URL">
        Enter `https://mcp.jam.dev/mcp`.
      </Step>

      <Step title="Name the server">
        Enter `Jam`.
      </Step>
    </Steps>

    Your `mcp.json` file should look like this:

    ```json theme={"theme":"css-variables"}
    {
      "servers": {
        "Jam": {
          "url": "https://mcp.jam.dev/mcp",
          "type": "http"
        }
      }
    }
    ```
  </Tab>

  <Tab title="Windsurf">
    <Steps>
      <Step title="Open the command palette">
        Press `Ctrl`/`Cmd` + `P` and enter `>MCP: Add Server`.
      </Step>

      <Step title="Select the transport type">
        Select **HTTP (Server-Sent Events)**.
      </Step>

      <Step title="Enter the server URL">
        Enter `https://mcp.jam.dev/mcp`.
      </Step>

      <Step title="Name the server">
        Enter `Jam`.
      </Step>
    </Steps>

    Your `mcp.json` file should look like this:

    ```json theme={"theme":"css-variables"}
    {
      "mcp": {
        "servers": {
          "Jam": {
            "type": "http",
            "url": "https://mcp.jam.dev/mcp"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="OpenCode">
    Edit your `opencode.json`:

    ```json theme={"theme":"css-variables"}
    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "jam": {
          "type": "remote",
          "url": "https://mcp.jam.dev/mcp"
        }
      }
    }
    ```

    Then run the following command to start the OAuth2 authorization flow:

    ```bash theme={"theme":"css-variables"}
    opencode mcp auth jam
    ```
  </Tab>
</Tabs>

## Step 2: Start using Jam MCP

Once your MCP client is configured:

<Steps>
  <Step title="Copy your Jam link">
    Copy one or more Jam links from your workspace.
  </Step>

  <Step title="Prompt your agent">
    Paste the Jam link into your agent's chat and describe what you need. See
    the prompting tips and examples below.
  </Step>

  <Step title="Authenticate">
    Authenticate your IDE with Jam when prompted.
  </Step>

  <Step title="Approve tool requests">
    Approve any tool requests the agent makes as it reads your Jam data.
  </Step>
</Steps>

## Available MCP tools

### Read Jam data

| <ToolHeader /> | Description |
| - | - |
| `getDetails` | Get a quick snapshot of the Jam: who made it, what happened, and which other tools to try next. |
| `getConsoleLogs` | Grab the console logs from the Jam. Supports `logLevel`, `limit`, and `after` (page cursor) filters to reduce noise. |
| `getNetworkRequests` | List every web request from the Jam as JSON. Supports `statusCode`, `contentType`, `host`, `method`, `limit`, and `after` filters, plus `bodies` (`errors` by default, or `all`). |
| `getUserEvents` | Read each click, input, and page navigation change in plain language. |
| `getMetadata` | Read custom key-value metadata set via the `jam.metadata()` SDK: user IDs, app versions, feature flags, and more. |
| `getScreenshots` | Get every screenshot from a screenshot Jam for visual inspection. |
| `getVideoTranscript` | Get the spoken transcript from a video Jam where the microphone was enabled, in WebVTT format with timestamps. |
| `getVideoChapters` | Get AI-generated chapter markers for a video Jam: titled segments with start and end timestamps. Text only. |
| `analyzeVideo` | Analyze a Jam video recording to extract insights, detect issues, and provide structured feedback. |
| `getFrames` | See what was on screen in a video Jam. Return frames at specific timestamps, evenly across a window, or one labeled overview grid spanning the whole recording. |

<Note>
  The video-only tools (`analyzeVideo`, `getVideoTranscript`,
  `getVideoChapters`, and `getFrames`) and `getScreenshots` are not available
  for Instant Replay Jams. All other MCP tools work and return data for Instant
  Replay Jams.
</Note>

### Search and browse

| <ToolHeader /> | Description |
| - | - |
| `searchJams` | Search Jams by text across titles, descriptions, comments, linked issues, and transcripts. Filter by author, folder, type, date, and more. |
| `listMembers` | Browse your team members. |
| `listFolders` | Browse available folders. |

Search filters go well beyond author and folder. Your agent can find Jams by:

* **Page URL**: Jams captured on a page URL such as `/checkout`.
* **Source**: Jams from the extension, the Mac app, iOS, Recording Links, and more. Narrow further to a specific Recording Link, or to links that share a reference.
* **Linked issue**: Jams sent to an integration, or with an issue key such as `JIRA-123`.
* **Environment**: country, browser, OS, incognito session, etc.
* **Date**: Jams created in a date range, such as the last seven days.
* **Exclusions**: everything except a specific author, folder, or Jam type.

Combine any of these with search text in one request.

### Comment and react

| <ToolHeader /> | Description |
| - | - |
| `createComment` | Add Markdown comments to a Jam, optionally mentioning a teammate to notify them. |
| `editComment` | Rewrite a comment you left earlier, so an agent can correct its own note instead of stacking a follow-up. |
| `deleteComment` | Delete a comment you wrote, along with its attachments. |
| `addReaction` | React to a comment. Handy for acknowledging one you've already acted on. |
| `removeReaction` | Take back a reaction you left on a comment. |

### Organize Jams and folders

| <ToolHeader /> | Description |
| - | - |
| `updateJam` | Rename a Jam, rewrite its description, or move it between folders using a folder ID or folder name. |
| `deleteJam` | Delete a Jam. It leaves your lists and search, and there is no way to restore it. |
| `createFolder` | Create a folder to organize Jams into. Returns the folder's ID and short ID so a follow-up `updateJam` can file a Jam into it. |
| `updateFolder` | Rename a folder, addressed by its name, ID, or short ID. |
| `deleteFolder` | Delete a folder and every Jam inside it, none of them restorable. Returns how many Jams went with it. |

### Recording Links

| <ToolHeader /> | Description |
| - | - |
| `listRecordingLinks` | List the team's recording links, newest first, with cursor pagination and an `includeRevoked` option. |
| `getRecordingLink` | Get one recording link by its public ID. |
| `listRecordingLinkJams` | List the Jams recorded through a link, by public ID, with cursor pagination. |
| `createRecordingLink` | Create a reusable recording link, optionally targeting a folder, connected domain, or expiration. |
| `updateRecordingLink` | Edit a link's name, folder, reference, Jam title, expiration, or metadata by public ID (revoked links can't be edited). |
| `deleteRecordingLink` | Revoke a link by its public ID (soft-delete, so collected Jams stay). |
| `listRecordingUrls` | List the team's connected recording domains. |
| `getRecordingUrlVerifyLink` | Start verifying a connected domain and return a link a human opens to confirm it. |

### Seeing what was on screen

`getVideoTranscript` and `analyzeVideo` describe a video Jam in text, but sometimes your agent needs the actual pixels. `getFrames` returns still frames from the recording as images, so your agent can look at the screen at the moments that matter.

Call it three ways:

* **Overview grid.** Set `overview: true` to get one image: frames evenly spaced across the whole video, stitched into a labeled grid where each cell shows its timestamp. The frame count scales with the video's length (6 for short clips up to 16 for long ones). This is the fastest way for an agent to orient itself on a visual bug before drilling in.
* **Specific timestamps.** Pass `at` with one or more times in milliseconds to capture those exact moments.
* **Window.** Pass `fromMs`, `toMs`, and `count` to sample evenly-spaced frames across a range.

Use `size` (`small`, `medium`, `large`; default `medium`) to trade detail against your agent's context budget. The overview grid ignores `size` and always renders small cells. Each frame comes back as an image preceded by a `t=<ms>` text anchor so the agent knows which moment it's looking at.

<Note>
  `getFrames` works only on video Jams whose recording is hosted on Cloudflare
  Stream. Screenshot Jams, and videos not yet on Cloudflare, return a short text
  block explaining why instead of images.
</Note>

## Prompting tips

* Use Jam MCP to help with bug analysis, product feedback, and giving agents the context they need to debug issues.
* Be as specific as you would with another engineer for the best results.
* Start with small features or bug fixes. Tell your agent to propose a plan using Jam MCP and verify its plan before moving on to suggested edits.

## Examples

Here are three ways the team at Jam uses Jam MCP in their own workflow.

### Bug analysis

**Tomasz (Product Engineer)** uses Jam MCP to debug issues by providing bug context to Cursor to ship a fix.

```text theme={"theme":"css-variables"}
Review this Jam [Jam Link] and analyze the problem, cross-reference it with the existing codebase, and prepare a detailed plan for implementation.
```

Stack: Jam recordings + Jam MCP + Cursor

***

### Product feedback triage

**Frits (Product Manager)** lets Claude review and analyze customer Jams to spot common issues and patterns, then turns findings into grouped Linear tickets.

```text theme={"theme":"css-variables"}
Analyze these Jams, perform root-cause analysis, and organize them into efficient work packages to minimize engineers' context switching; create Linear tickets from the analysis.

[Jam Link]
```

Stack: Jam customer recordings + Jam MCP + Claude Desktop + Linear MCP

***

### Implementation planning from design feedback

**Martin (Product Designer)** records product and design feedback with the Jam extension. Jam MCP provides the context for Claude Code to plan and ship a ready-to-review PR.

```text theme={"theme":"css-variables"}
I recorded product feedback in a Jam. Create an implementation plan for the changes requested in this Jam:

[Jam Link]
```

Stack: Jam extension + Jam MCP + Claude Code inside Cursor

## Managing MCP access

Go to [**Settings → MCP**](https://jam.dev/s/settings/mcp) to see connected tools. Select any tool to revoke or disconnect access at any time.

<Info>
  MCP mirrors your existing Jam permissions. It does not grant new access beyond
  what a user can already see in the Jam web or mobile apps. Use your normal
  admin controls for members and roles, or SSO in
  [**Settings**](https://jam.dev/s/settings).
</Info>

## FAQ

<AccordionGroup>
  <Accordion title="Can I use MCP without the Chrome extension?">
    Yes. You only need an existing Jam link. Anyone (you, your workspace, or a
    customer) can record a Jam. If you want to record and create new Jams
    yourself, install the Chrome extension or use the iOS app.
  </Accordion>

  <Accordion title="Can I paste multiple Jam links at once?">
    Yes. You can paste more than one link, but we recommend one Jam at a time so
    your agent doesn't hit context window limits.
  </Accordion>

  <Accordion title="Does Jam MCP send my Jam data to third parties?">
    Some MCP tools use Google's Gemini. Jam opts out of training on customer
    data and takes steps to de-identify it. See the [Security page](/docs/security)
    for more details on Jam's AI data policy.
  </Accordion>

  <Accordion title="Does MCP work the same with Instant Replay Jams?">
    Not exactly. The video-only tools (`analyzeVideo`, `getVideoTranscript`,
    `getVideoChapters`, and `getFrames`) and `getScreenshots` are not available
    for Instant Replay Jams. All other MCP tools still work and return data and
    context.
  </Accordion>

  <Accordion title="How can admins control what MCP can access?">
    MCP mirrors your existing Jam permissions. It doesn't grant new access. Use
    your normal admin controls for members and roles, or SSO in
    [**Settings**](https://jam.dev/s/settings). Nothing is exposed via MCP that
    a user couldn't already see in the Jam web or mobile apps.
  </Accordion>
</AccordionGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.