## Documentation Index

Fetch the complete documentation index at: [/docs/llms.txt](/content/docs/llms.txt)

Use this file to discover all available pages before exploring further.

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.

1. Install the Jam Chrome extension  
   Install the [Chrome extension](https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci) from the Chrome Web Store.

2. Record a Jam  
   Hit **Record** to capture your screen and voice.

3. Copy your Jam link  
   Stop the recording. Your Jam link is ready for an agent to consume via MCP.

## Step 1: Configure your MCP client

- ChatGPT
- Claude Desktop
- Claude Code
- Codex
- Cursor
- VS Code
- Windsurf
- OpenCode

1. Open settings  
   From the ChatGPT home page, go to **Settings**.

2. Navigate to connectors  
   Click **Apps & Connectors**.

3. Connect Jam  
   Select **Jam** and click the **Connect** button.

4. Authorize  
   Sign in to Jam and allow access to your workspace.

1. Open search and tools  
   From the Claude home page, click **search and tools** on web or desktop.

2. Add a connector  
   Click **+Add connectors**.

3. Connect Jam  
   Find **Jam** in the Connector Directory and click the button to connect.

4. Authorize  
   Sign in to Jam and pick the workspace Claude should access.

Install [Claude Code in your IDE](https://docs.anthropic.com/en/docs/claude-code/ide-integrations), then run the following command in your terminal:

```
claude mcp add Jam https://mcp.jam.dev/mcp -t http -s user
```

1. Open or create the config file at `~/.codex/config.toml`  
2. Add the following to your config file and save:

```
[mcp_servers.jam]
url = "https://mcp.jam.dev/mcp"
```

Add the following to your Cursor MCP configuration:

```
{
  "mcpServers": {
    "jam": {
      "url": "https://mcp.jam.dev/mcp"
    }
  }
}
```

Restart Cursor after making this change for it to take effect.

1. Open the command palette  
   Press `Ctrl`/`Cmd` \+ `P` and enter `>MCP: Add Server`.

2. Select the transport type  
   Select **HTTP (HTTP or Server-Sent Events)**.

3. Enter the server URL  
   Enter `https://mcp.jam.dev/mcp`.

4. Name the server  
   Enter `Jam`.

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

```
{
  "servers": {
    "Jam": {
      "url": "https://mcp.jam.dev/mcp",
      "type": "http"
    }
  }
}
```

1. Open the command palette  
   Press `Ctrl`/`Cmd` \+ `P` and enter `>MCP: Add Server`.

2. Select the transport type  
   Select **HTTP (Server-Sent Events)**.

3. Enter the server URL  
   Enter `https://mcp.jam.dev/mcp`.

4. Name the server  
   Enter `Jam`.

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

```
{
  "mcp": {
    "servers": {
      "Jam": {
        "type": "http",
        "url": "https://mcp.jam.dev/mcp"
      }
    }
  }
}
```

Edit your `opencode.json`:

```
{
  "$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:

```
opencode mcp auth jam
```

## Step 2: Start using Jam MCP

Once your MCP client is configured:

1. Copy your Jam link  
   Copy one or more Jam links from your workspace.

2. Prompt your agent  
   Paste the Jam link into your agent’s chat and describe what you need. See the prompting tips and examples below.

3. Authenticate  
   Authenticate your IDE with Jam when prompted.

4. Approve tool requests  
   Approve any tool requests the agent makes as it reads your Jam data.

## Available MCP tools

| Tool                   | 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` and `limit` filters to reduce noise. |
| `getNetworkRequests`   | List every web request from the Jam as JSON. Supports `statusCode`, `contentType`, `host`, and `limit` filters. |
| `getScreenshot`        | Get every screenshot from a screenshot Jam for visual inspection. |
| `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. |
| `getVideoTranscript`   | Get the spoken transcript from a video Jam where the microphone was enabled, in WebVTT format with timestamps. |
| `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. |
| `listJams`           | Search and filter Jams by text, type, folder, author, URL, or date. |
| `listMembers`         | Browse your team members. |
| `listFolders`         | Browse available folders. |
| `createComment`       | Add Markdown comments to a Jam. |
| `updateJam`           | Move Jams between folders using a folder ID or folder name. |
| `listRecordingUrls`    | List the team’s connected recording domains. |
| `getRecordingUrlVerifyLink` | Start verifying a connected domain and return a link a human opens to confirm it. |
| `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). |
| `revokeRecordingLink`   | Revoke a link by its public ID (soft-delete, so collected Jams stay). |

`getScreenshot` and `analyzeVideo` are not available for Instant Replay Jams. All other MCP tools work and return data for Instant Replay Jams.

### 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. Each frame comes back as an image preceded by a `t=<ms>` text anchor so the agent knows which moment it’s looking at.

`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.

## 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.

```
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.

```
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.

```
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**](/content/s/settings/mcp/index.html) to see connected tools. Select any tool to revoke or disconnect access at any time.

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**](/content/s/settings/index.html).

## FAQ

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.

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.

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](/content/docs/security/index.html) for more details on Jam’s AI data policy.

Does MCP work the same with Instant Replay Jams?

Not exactly. `getScreenshot` and `analyzeVideo` are not available for Instant Replay Jams. All other MCP tools still work and return data and context.

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**](/content/s/settings/index.html). Nothing is exposed via MCP that a user couldn’t already see in the Jam web or mobile apps.