# About
Source: https://jam.dev/docs/about

Learn when Jam was founded, who uses Jam, and how to contact the team.

Jam was founded in 2020 to make bug reporting faster for people and AI agents.

Software teams at companies such as Ramp, Drata, Perplexity, ElevenLabs, and Autodesk use Jam to capture clear bug reports with the context developers need. Jam is backed by early investors from Apple, GitHub, Slack, Cloudflare, and PagerDuty, with institutional investors including Union Square Ventures, BoxGroup, Version One Ventures, and Village Global.

<Card title="Get in touch" icon="envelope" href="mailto:hello@jam.dev">
  Have feedback, questions, or just want to say hi? Reach the team at [**hello@jam.dev**](mailto:hello@jam.dev). We read everything.
</Card>


# Access Controls
Source: https://jam.dev/docs/access-controls

Set default access for every Jam in your workspace, and adjust visibility on any single Jam when one needs tighter control.

<Info>
  Available to workspaces on our [Team](https://jam.dev/pricing) or [Enterprise](https://jam.dev/pricing) plans.
</Info>

<img alt="Jam access picker with Anyone with the link selected and Workspace members only as the alternative" />

Set a default access policy for every Jam in your workspace, and override it on individual Jams when needed.

## Default link access

Control default access for every Jam in your workspace:

1. **Anyone with the link**: Anyone with the link can view
2. **Workspace members only**: Only members of your workspace can view

Modify the default access controls in [**Settings**](https://jam.dev/s/settings). Override defaults for individual Jams:

<Tabs>
  <Tab title="Default Workspace Setting">
    <img alt="Default link access setting with Anyone with link selected for the workspace" />

    Set a default that applies to all existing and new Jams in your workspace. Only workspace Admins can change this setting.

    <Steps>
      <Step title="Open Settings">
        Go to [**Settings**](https://jam.dev/s/settings).
      </Step>

      <Step title="Locate the Default link access section" />

      <Step title="Choose an access level">
        * **Anyone with the link**: Anyone with the link can view
        * **Workspace members only**: Only members of your workspace can view
      </Step>
    </Steps>
  </Tab>

  <Tab title="Individual Jam">
    Override defaults for individual Jams:

    <Steps>
      <Step title="Open the Jam">
        Open any Jam you want to adjust.
      </Step>

      <Step title="Click the more ">
        Click **chevron** next to the copy link button <Icon icon="chevron-down" />
      </Step>

      <Step title="Choose an access level">
        Select **Anyone with the link** or **Workspace members only**.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## FAQ

<AccordionGroup>
  <Accordion title="What's the difference between Anyone with the link and Workspace members only?">
    `Anyone with the link` lets anyone with the link view the Jam (no login required). `Workspace members only` requires users to log in and be part of your workspace.
  </Accordion>
</AccordionGroup>


# AI apps
Source: https://jam.dev/docs/ai-apps

Capture bugs in your AI app with all the context engineers need to debug prompts, model settings, and unpredictable behavior.

Jam captures AI app logs automatically so engineers pinpoint issues fast.

### Custom logs

Use [custom logs](/docs/custom-logs) to log parameters such as temperature, max token length, context window size, or any custom settings you need.

**How it helps.** Spot configuration changes like temperature shifts or new system prompts that cause unexpected behavior. Every bug report includes version numbers, system prompts, and configuration settings.

### Instant Replay

Use [Instant Replay](/docs/instant-replay) to catch unpredictable bugs when a model returns incorrect responses or hallucinations.

**How it helps:**

* **Context drift.** AI apps lose track of earlier context, producing inconsistent or irrelevant outputs. Use Instant Replay to show engineers where the conversation drifted.
* **Error and exception details.** AI bots sometimes fail silently or return a generic error. With Instant Replay you capture the bug the moment it happens. No reproduction required.

*Bonus: with [Jam AI](/docs/jam-ai) you get automatic repro steps, and engineers always get a useful ticket.*

### DevTools

Engineers see full stack traces and console logs in [DevTools](/docs/devtools) to spot issues in your AI app.

**How it helps. Output variability and latency.** When an AI app returns inconsistent responses, console and network logs reveal unexpected API responses or token limits.

### Backend logs

Capture server-side errors with the [Sentry](/docs/sentry) integration so engineers can diagnose rate limits and misconfigured API endpoints.

**How it helps. Backend diagnostics.** When your AI backend fails (HTTP 503 errors, LLM API timeouts), errors log automatically and attach to the bug report.

### Screen recording

Use [video screen recording](/docs/video) to capture the intermediate steps the AI takes while reasoning.

**How it helps. Chain-of-thought debugging.** When answers are incorrect or incomplete, capture the reasoning state so engineers can review the steps the model took.

If we can help you configure Jam for your AI app, [DM us on X](https://x.com/jamdotdev) or [reach out to our team](https://jam.dev/contact-sales).


# AI policy
Source: https://jam.dev/docs/ai-policy

See how Jam builds AI features responsibly: what data we use, how we protect it, and how we work with third-party model providers.

## Building Jam AI

Jam AI automates repetitive tasks and clarifies bug reports. Whether you're generating ticket descriptions, capturing reproduction steps, or debugging, Jam AI keeps you focused on solving issues rather than documenting them.

### Our Approach

Jam's AI features are powered by third-party AI models that help you create and resolve bugs faster. Automatic ticket creation, reproduction step generation, and the AI Debugger all speed up your workflow. We're continually improving Jam AI with smarter models that better understand debugging patterns and technical documentation.

### Data and privacy

We keep your data safe. Our AI model development process protects your privacy and confidential information.

For all customer data, we:

* Encrypt data at rest and in transit
* Implement security measures to prevent unauthorized access
* Provide granular user access controls and permissions
* Give you the ability to manage AI features per workspace

When working with third-party AI providers, we:

* Do not allow them to train their models on customer data
* Limit how long vendors can store data
* Take steps to de-identify and anonymize content

For general information about security at Jam, visit the [Security](/docs/security) page.


# Asana
Source: https://jam.dev/docs/asana

Turn every Jam into an Asana task with full technical context. Set workspace, project, and assignee from inside the extension.

<iframe />

Connect Jam to Asana to turn every bug capture into an Asana task in seconds. All the technical details your engineers need are attached automatically. No manual copy-pasting of logs or device information.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every Asana task

Every Asana task created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create an Asana task from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Asana as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Asana.
      </Step>

      <Step title="Authenticate with Asana">
        Complete the Asana OAuth flow to connect your account.
      </Step>

      <Step title="Configure your Asana task">
        Once connected, set up your task from Jam: choose the workspace, project, assignee, tags, and more.
      </Step>

      <Step title="Create the task">
        Click **Create task**. Jam creates the Asana task and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during task setup to manage which Asana fields appear in the Jam extension. Remove fields you don't need to keep your bug-reporting workflow fast.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to Asana">
    Create an Asana task from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into an Asana task.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Asana.
      </Step>

      <Step title="Log in to Asana if prompted">
        If this is your first time using Jam + Asana, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the task details">
        Enter the workspace, project, assignee, tags, and any other fields you need.
      </Step>

      <Step title="Create the task">
        Click **Create task** to send the Jam to Asana.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Audit Logs
Source: https://jam.dev/docs/audit-logs

Track every access change, membership update, and settings change in your workspace. Essential for security reviews and compliance audits.

<Info>
  Audit logs are available on the [**Enterprise**](https://jam.dev/pricing) plan only.
</Info>

## What gets logged

Audit logs capture three main categories of workspace activity:

| Activity type              | What's logged                                                                         |
| -------------------------- | ------------------------------------------------------------------------------------- |
| **Access control changes** | Changes to workspace, folder, and individual Jam permissions                          |
| **Membership events**      | User invitations, removals, and role modifications                                    |
| **Settings changes**       | Data retention updates, AI feature toggles, and other workspace configuration changes |

## How it works

Every logged event captures four pieces of information:

* **Who** performed the action
* **What** was changed
* **When** it happened
* **Context** around the change

You get a complete record of who did what and when, so you can spot unauthorized changes.

## Key benefits

* **Security oversight:** Monitor access control changes and user permissions in real-time
* **Team accountability:** Track member invitations, role changes, and removals
* **Configuration tracking:** See when critical settings like data retention and AI features are modified
* **Compliance support:** Meet security audit and regulatory requirements

## Enable audit logs

Contact us to enable audit logs for your workspace

[Contact sales](https://jam.dev/contact-sales)


# Auto-blur
Source: https://jam.dev/docs/auto-blur

Hide sensitive content automatically during Recording Link sessions. Passwords, personal info, and secrets never reach Jam's servers.

Auto-blur hides sensitive content in real time during Recording Link sessions. Blurred content never reaches Jam's servers.

## How it works

The Jam.js snippet automatically detects and blurs sensitive content during recording sessions. When a customer records:

1. Sensitive elements are blurred in real time. If an end-user needs to access blurred content, they can pause the recording.
2. Only the blurred version is captured. Sensitive data never reaches Jam's servers.
3. The final Jam shows blurred content exactly as during recording. Console logs show `<redacted>`.

**What gets blurred:** only the elements you want

**Applies to:** Jams requested via Intercom or Recording Link

<Info>By default, Jam recognizes the same privacy selectors used by FullStory, Hotjar, LogRocket, Sentry, and others. If you're already using these tools, your existing privacy setup works automatically with Jam.</Info>

## Setup

<Warning>Blurred content is only supported on sites with verified Jam.js installations. Follow the Recording Links setup guide before proceeding.</Warning>

Blurring is enabled by default once the snippet is installed.

### Quickstart

#### Want to blur something?

Use data attributes:

```html theme={"theme":"css-variables"}
<span data-jam-blur>{ccNumber}</span>
```

Or meta tag:

```html theme={"theme":"css-variables"}
<meta name="jam:blur" content=".secret-stuff" />
```

Or SDK:

```javascript theme={"theme":"css-variables"}
jam.initialize({ blurSelectors: ".secret-stuff" });
```

#### Want to unblur something?

```html theme={"theme":"css-variables"}
<span class="cc-number" data-jam-blur="no">{ccNumber}</span>
```

### What gets blurred automatically

#### Standard selectors

* **Jam:** `[data-jam-blur]`
* **rrweb:** `.rr-block`, `.rr-mask`, `.rr-ignore`
* **Standard HTML autocomplete attributes:** `cc-number`, `cc-exp`, `cc-csc`, `tel`, `email`
* **Common name/id patterns** for SSN, bank accounts, credit cards, photo IDs, driver's license

#### Session replay tools

* **FullStory:** `.fs-exclude`, `.fs-mask`, `.fs-block`, `.fs-unmask` (unblur)
* **Hotjar:** `[data-hj-suppress]`, `[data-hj-masked]`
* **LogRocket:** `[data-private]`
* **Microsoft Clarity:** `[data-clarity-mask]`, `[data-clarity-unmask]` (unblur)
* **Sentry:** `.sentry-block`, `.sentry-mask`, `[data-sentry-block]`, `[data-sentry-mask]`
* **OpenReplay:** `[data-openreplay-obscured]`, `[data-openreplay-hidden]`
* **Highlight.io:** `.highlight-block`, `.highlight-mask`, `.highlight-ignore`
* **ContentSquare:** `[data-cs-mask]`, `[data-cs-encrypt]`, `[data-cs-capture]` (unblur)
* **Matomo:** `[data-matomo-mask]`

#### Analytics tools

* **Heap:** `[data-heap-redact-text]`, `[data-heap-redact-attributes]`, `[data-heap-ignore]`, `.heap-ignore`
* **Amplitude:** `[data-amp-mask]`, `[data-amp-unmask]` (unblur)

### Add custom selectors

#### Using SDK

```javascript theme={"theme":"css-variables"}
import * as jam from "@jam.dev/recording-links/sdk";

jam.initialize({ blurSelectors: ".my-custom-blur-class" });

// or array
jam.initialize({ blurSelectors: [".blur-class-1", ".blur-class-2"] });

// or function
jam.initialize({ blurSelectors: () => `.my-${Math.ceil(Math.random() * 100)}-blur-class` });
```

#### Using script tag with meta tags

```html theme={"theme":"css-variables"}
<meta name="jam:blur" content=".my-custom-blur-class" />
```

### Opt out of blurring for specific elements

Use `[data-jam-blur="no"]`:

```html theme={"theme":"css-variables"}
<div class="rr-block" data-jam-blur="no">Blurred in rrweb, but not in Jam</div>
```

### Test before you ship

<Steps>
  <Step title="Create a Recording Link">
    Create a Recording Link using your verified recording URL.
  </Step>

  <Step title="Start a test recording">
    Click your own link and start recording.
  </Step>

  <Step title="Visit pages with sensitive content">
    Navigate to pages that should be blurred and confirm the behavior.
  </Step>
</Steps>

### Limitations

* Content in iframes cannot be selectively blurred
* Flashes of unblurred content may occur during captured pageloads
* When browser window is resized during recording, blurred content may briefly become visible


# Auto-deploy
Source: https://jam.dev/docs/auto-deploy

Install Jam on every browser in your organization automatically using Google Admin Console. No manual setup.

Enterprise admins give every member instant Jam access through the Google Admin Console.

## How to set up Jam in Google Admin Console

<Info>
  **Prerequisite:** Make sure you have Google Workspace Admin Access.
</Info>

<Steps>
  <Step title="Log in to Google Admin">
    Navigate to [admin.google.com](https://admin.google.com) and log in with admin credentials.
  </Step>

  <Step title="Open Chrome apps and extensions">
    Go to **Devices → Chrome → Apps & extensions → Users & Browsers**.
  </Step>

  <Step title="Add Jam from the Chrome Web Store">
    Click **+ Add → Add from Chrome Web Store**.
  </Step>

  <Step title="Select Jam">
    Search for **jam.dev** and select it.
  </Step>

  <Step title="Set the installation policy">
    Set the policy to **Force Install** or **Force install + pin to browser toolbar**.
  </Step>

  <Step title="Save">
    Click **Save** to apply settings.
  </Step>
</Steps>

Jam installs automatically the next time employees open Chrome.


# Azure DevOps
Source: https://jam.dev/docs/azure-devops

Turn every Jam into an Azure DevOps work item with full technical context. Set project, type, and priority from inside the extension.

Connect Jam to Azure DevOps to turn every bug capture into a work item with full debug context already attached. Engineers get everything they need to reproduce the issue without any manual information gathering.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## Prerequisites

Before connecting Jam to Azure DevOps, enable third-party OAuth access in your Azure DevOps organization:

1. Go to your Azure DevOps organization settings.
2. Under **Policies**, enable **Third-party application access via OAuth**.

## What's included in every Azure DevOps work item

Every Azure DevOps issue created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create an Azure DevOps work item from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Azure DevOps as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Azure DevOps.
      </Step>

      <Step title="Authenticate with Azure DevOps">
        Complete the Azure DevOps OAuth flow to connect your account.
      </Step>

      <Step title="Configure your work item">
        Once connected, set up your work item from Jam: choose the project, team, priority, assignees, and more.
      </Step>

      <Step title="Create the work item">
        Click **Create issue**. Jam creates the Azure DevOps work item and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during work item setup to manage which Azure DevOps fields appear in the Jam extension. Remove fields you don't use to keep the process fast.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to Azure DevOps">
    Create an Azure DevOps work item from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into an Azure DevOps work item.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Azure DevOps.
      </Step>

      <Step title="Log in to Azure DevOps if prompted">
        If this is your first time using Jam + Azure DevOps, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the work item details">
        Enter the project, team, priority, and any other fields you need.
      </Step>

      <Step title="Create the work item">
        Click **Create issue** to send the Jam to Azure DevOps.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Browser support
Source: https://jam.dev/docs/browser-support

See which Chromium browsers Jam supports and which features work in each.

Jam is supported on all Chromium browsers: Chrome, Edge, Arc, Brave, Opera. More browser support is coming soon. Jam supports both logged in and incognito browser sessions.

## Supported browsers

| Browser | Console logs | Network requests | WebSockets    |
| ------- | ------------ | ---------------- | ------------- |
| Chrome  | ✅            | ✅                | ✅             |
| Edge    | ✅            | ✅                | ✅             |
| Arc     | ✅            | ✅                | ✅             |
| Brave   | ✅            | ✅                | Not supported |
| Opera   | ✅            | ✅                | ✅             |

<Note>
  Firefox and Safari are not currently supported.
</Note>

Install the Jam extension from the [Chrome Web Store](https://chrome.google.com/webstore/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci). The same extension works across all supported Chromium browsers.

For detailed incognito setup, see [Incognito Sessions](/docs/extension-setup#incognito-sessions).


# CLI
Source: https://jam.dev/docs/cli

Authenticate, read Jam data, and create Jams from your terminal. Built for shell scripts, CI jobs, and AI coding agents.

The Jam CLI runs every Jam read and write from your terminal. Authenticate once, then pipe Jam data into shell scripts, CI jobs, or AI coding agents.

<Info>
  The CLI runs on macOS, Linux, and Windows (x64 and arm64). Windows publishes an x64 binary; Windows on ARM runs it under the built-in x64 emulation. You can also run the CLI under Windows Subsystem for Linux (WSL) — on WSL, authenticate with a personal access token (see [Authenticate](#authenticate)).
</Info>

## Install

<Tabs>
  <Tab title="macOS / Linux">
    Run the installer:

    ```bash theme={"theme":"css-variables"}
    curl -fsSL https://native.jam.dev/install | bash
    ```

    The script detects your OS and architecture, downloads the matching binary into `~/.local/bin/jam`, and adds that directory to your shell `PATH`. Open a new shell or `source` your rc file, then confirm the install:

    ```bash theme={"theme":"css-variables"}
    jam --version
    ```
  </Tab>

  <Tab title="Windows">
    Open PowerShell and run:

    ```powershell theme={"theme":"css-variables"}
    powershell -c "irm https://native.jam.dev/install.ps1 | iex"
    ```

    The script downloads the binary into `%LOCALAPPDATA%\Programs\Jam`, points a `jam` command at it, and adds it to your user `PATH`. Open a new terminal, then confirm the install:

    ```powershell theme={"theme":"css-variables"}
    jam --version
    ```

    <Note>
      Only an x64 binary is published. Windows on ARM runs it under the built-in x64 emulation — the same one-liner works, with no extra steps.
    </Note>

    **Locked-down PowerShell.** If your environment blocks `irm | iex` (a restricted execution policy is common on managed machines), install by hand: download the binary from [`https://native.jam.dev/download/windows/x64`](https://native.jam.dev/download/windows/x64), save it as `jam.exe` in a folder such as `%LOCALAPPDATA%\Programs\Jam\bin`, then add that folder to your `PATH` under **Settings → Edit environment variables for your account**. Open a new terminal and run `jam --version`.
  </Tab>
</Tabs>

### Creating video Jams needs ffmpeg

`jam create jam` extracts the poster image and probes the audio track with `ffmpeg`/`ffprobe` when you create a **video** Jam. Every other command works without it. Install ffmpeg if you plan to create video Jams from the CLI:

<CodeGroup>
  ```bash macOS theme={"theme":"css-variables"}
  brew install ffmpeg
  ```

  ```bash Linux theme={"theme":"css-variables"}
  sudo apt install ffmpeg
  ```

  ```powershell Windows theme={"theme":"css-variables"}
  winget install ffmpeg
  ```
</CodeGroup>

Or skip ffmpeg entirely by passing `posterImagePath` and `screenDimensions` explicitly on the create payload.

## Authenticate

Every read and write command needs an authenticated session. The CLI supports two modes.

<Note>
  On WSL, use a personal access token. The browser login flow expects your browser and the CLI to share the same local address, which WSL splits between Windows and Linux, so token auth is the reliable path for now.
</Note>

<Tabs>
  <Tab title="Browser OAuth">
    Run:

    ```bash theme={"theme":"css-variables"}
    jam auth login
    ```

    The CLI opens an OAuth flow in your default browser, exchanges the authorization code for access and refresh tokens, and stores them in `~/.config/jam/credentials.json`.
  </Tab>

  <Tab title="Personal access token">
    Use a personal access token for headless environments, CI jobs, or WSL:

    ```bash theme={"theme":"css-variables"}
    echo "jam_pat_abc123..." | jam auth login --token
    ```

    Create PATs in [**Settings → MCP**](https://jam.dev/s/settings/mcp). See [Personal Access Tokens](/docs/personal-access-tokens) for scopes, expiration, and rotation guidance.
  </Tab>
</Tabs>

### Check auth status

```bash theme={"theme":"css-variables"}
jam auth status
```

Prints the authenticated user, workspace, and auth method. Pass `--json` to consume the same data from a script.

### Log out

```bash theme={"theme":"css-variables"}
jam auth logout
```

Revokes tokens server-side where supported and clears the local credential store.

### Where credentials live

The CLI stores credentials at `~/.config/jam/credentials.json` with `0600` permissions, the same model used by `gh`, `aws`, `gcloud`, and other major developer CLIs.

Bypass the credential file entirely by setting `JAM_TOKEN` in your shell. The CLI uses the env-var token for the lifetime of the process and never writes it to disk.

## First steps

After install and auth, run this short loop to confirm the CLI talks to your workspace:

```bash theme={"theme":"css-variables"}
jam auth status
jam list jams --limit 5
jam get jam <id>
```

`auth status` confirms the CLI can read the stored token. `list jams` returns a page of Jams from your workspace. `get jam` walks a single Jam by ID. From there, scan the [command reference](#command-reference) for the command you need.

## Command reference

Every command supports `--help`. The machine-readable surface (argument types, flags, output shapes) lives at `jam agent-context`.

| Command                                                                                                                                                          | Summary                                                       | Output      |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- | ----------- |
| `jam auth login [--token]`                                                                                                                                       | Authenticate via browser OAuth or stdin PAT                   | Side effect |
| `jam auth logout`                                                                                                                                                | Revoke tokens and clear credentials                           | Side effect |
| `jam auth status`                                                                                                                                                | Show current user, workspace, and auth method                 | Single      |
| `jam get jam <id>`                                                                                                                                               | Fetch a Jam by ID                                             | Single      |
| `jam get metadata <id>`                                                                                                                                          | Structured `jam.metadata()` events                            | Paginated   |
| `jam get console <id> [--level <lvl>]`                                                                                                                           | Console log events                                            | Paginated   |
| `jam get network <id> [--status <code>] [--method <verb>] [--host <h>] [--content-type <ct>]`                                                                    | Network requests                                              | Paginated   |
| `jam get events <id>`                                                                                                                                            | Full unfiltered event stream                                  | Paginated   |
| `jam get transcript <id>`                                                                                                                                        | WebVTT transcript for video Jams                              | Single      |
| `jam get intents <id>`                                                                                                                                           | Cached intents summary                                        | Single      |
| `jam get screenshots <id> --out <dir>`                                                                                                                           | Download image media into a directory                         | Receipt     |
| `jam get frames <id> [--at <ms>] [--from <ms> --to <ms> --count <n>] [--size <s>] [--out <dir>]`                                                                 | Save still video frames as jpgs                               | Receipt     |
| `jam list jams [...]`                                                                                                                                            | List Jams in the workspace                                    | Paginated   |
| `jam list folders [...]`                                                                                                                                         | List folders                                                  | Paginated   |
| `jam list members [...]`                                                                                                                                         | List workspace members                                        | Paginated   |
| `jam create jam '<json>'`                                                                                                                                        | Create a screenshot or video Jam                              | Receipt     |
| `jam create comment <jamId> <body> [--at <ms>]`                                                                                                                  | Add a comment to a Jam                                        | Receipt     |
| `jam create folder <name>`                                                                                                                                       | Create a folder                                               | Receipt     |
| `jam create reaction <commentId> <emoji>`                                                                                                                        | React to a comment                                            | Receipt     |
| `jam update jam <id> [--title <title>] [--description <text>] [--folder <id>]`                                                                                   | Rename a Jam, rewrite its description, or move it to a folder | Receipt     |
| `jam update folder <folder> --name <name>`                                                                                                                       | Rename a folder                                               | Receipt     |
| `jam update comment <commentId> <body>`                                                                                                                          | Rewrite a comment you authored                                | Receipt     |
| `jam delete jam <id> [-y]`                                                                                                                                       | Archive a Jam                                                 | Receipt     |
| `jam delete comment <commentUid> [-y]`                                                                                                                           | Delete a comment you wrote                                    | Receipt     |
| `jam delete folder <id> [-y]`                                                                                                                                    | Delete a folder and archive the Jams in it                    | Receipt     |
| `jam delete reaction <commentId> <emoji>`                                                                                                                        | Take back your reaction on a comment                          | Receipt     |
| `jam recording-links urls`                                                                                                                                       | List connected recording domains                              | Paginated   |
| `jam recording-links list [--limit <n>] [--after <cursor>]`                                                                                                      | List the team's recording links                               | Paginated   |
| `jam recording-links get <id>`                                                                                                                                   | Fetch a recording link by public ID                           | Single      |
| `jam recording-links jams <id> [--limit <n>] [--after <cursor>]`                                                                                                 | List Jams recorded through a link                             | Paginated   |
| `jam recording-links create --name <name> [--recording-url-id <id>] [--folder <f>] [--jam-title <t>] [--reference <r>] [--expires-at <iso>] [--metadata <json>]` | Create a reusable recording link                              | Receipt     |
| `jam recording-links update <id> [--name <n>] [--folder <f>] [--reference <r>] [--jam-title <t>] [--expires-at <iso>] [--metadata <json>]`                       | Edit a recording link's settings                              | Receipt     |
| `jam recording-links revoke <id>`                                                                                                                                | Revoke a recording link                                       | Receipt     |
| `jam recording-links verify <url> [--wait]`                                                                                                                      | Verify a connected recording domain                           | Receipt     |
| `jam skills list`                                                                                                                                                | List bundled agent skills                                     | List        |
| `jam skills install [name] [--target <agent>] [--project]`                                                                                                       | Install bundled skill into an agent's directory               | Receipt     |
| `jam skills path [--target <agent>] [--project]`                                                                                                                 | Show where skills would be installed                          | Single      |
| `jam skills source`                                                                                                                                              | Print the absolute path to the bundled `SKILL.md`             | Path        |
| `jam agent-context`                                                                                                                                              | Print the machine-readable command surface as JSON            | Single      |
| `jam doctor`                                                                                                                                                     | Show CLI channel, URLs, version, and auth status              | Single      |
| `jam upgrade [--target <version>]`                                                                                                                               | Install the latest or pinned CLI binary                       | Side effect |
| `jam uninstall [-y]`                                                                                                                                             | Remove the CLI and local data                                 | Side effect |

### Read Jam data

Three commands return different views of the same Jam:

* `jam get jam <id>` returns the top-level record (title, author, URL, dates, folder, and kind-specific data).
* `jam get metadata <id>` returns structured metadata events emitted by the page via the `jam.metadata()` SDK call.
* `jam get intents <id>` returns the structured summary (what the user was trying to do, observed issues, impact). It returns `{ "status": "not_requested", "value": null }` when no summary is available. Treat that as absence, not an error.

Three commands return slices of the captured event stream:

* `jam get console <id> [--level error|warn|info|debug|log]`
* `jam get network <id> [--status 5xx|<code>] [--method GET|POST|...] [--host <substring>] [--content-type <ct>]`
* `jam get events <id>` returns the unfiltered event stream.

All three accept `--limit` (default 50, max 500) and `--after <cursor>` for pagination.

Two media reads:

* `jam get transcript <id>` returns `{ status, vtt }`. `vtt` is null while generation is pending.
* `jam get screenshots <id> --out <dir>` downloads the Jam's images into `<dir>`. For screenshot Jams that's the primary and secondary screenshots, for video and replay Jams it's the poster image.

### Video frames

`jam get frames <id>` saves still frames from a video Jam as jpgs, so you or an agent can see what was on screen instead of only reading the transcript. Frames land in `--out` (default `./jam-frames/<id>/`) and the command prints the saved paths as JSON.

```bash theme={"theme":"css-variables"}
# overview grid: no flags, one labeled image spanning the whole video
jam get frames <id>

# a single moment, or several explicit timestamps
jam get frames <id> --at 7000
jam get frames <id> --at 4000,7000,9000

# evenly-spaced frames across a window
jam get frames <id> --from 2000 --to 10000 --count 5
```

The mode depends on the flags:

* **Overview grid.** No flags. Saves one grid image with frames evenly spaced across the whole video, each cell labeled with its timestamp. The frame count scales with duration (6 for short clips up to 16 for long ones). Best for orienting before you know which moment you care about.
* **Timestamps.** `--at <ms>`, single or comma-separated. Saves one jpg per timestamp.
* **Window.** `--from <ms> --to <ms> --count <n>`. Saves N evenly-spaced frames across the range.

`--size` accepts `small`, `medium`, or `large` (default `medium`) and sets the frame height. When frames aren't available (a screenshot Jam, or a video not hosted on Cloudflare Stream), the command prints the reason to stderr and exits non-zero.

### List workspace collections

```bash theme={"theme":"css-variables"}
jam list jams --query "checkout" --type video --limit 20
jam list folders --order-by createdAt
jam list members --query "@example.com"
```

`--type` accepts `screenshot`, `video`, `replay`, or `unknown`. `--order-by` accepts `createdAt` or `updatedAt`. `--limit` defaults to 20 (max 500). All three list commands accept `--after <cursor>` for pagination. See `jam list jams --help` for all filters.

### Create and update Jams

Create a screenshot Jam from a JSON payload:

```bash theme={"theme":"css-variables"}
jam create jam '{
  "url": "https://example.com/checkout",
  "title": "Checkout button is broken",
  "screenshotPath": "./checkout.png",
  "screenDimensions": { "width": 1440, "height": 900 }
}'
```

The payload requires `url`, `screenDimensions`, and exactly one screenshot source (`screenshotPath`, `screenshotDataUrl`, or `screenshotMediaId`). To create a video Jam, set `kind` to `"video"` and provide `videoPath`. The poster image is generated downstream if you omit `posterImagePath`.

To avoid escaping a large JSON blob on the command line, read the payload from a file with an `@` prefix, or pipe it in on stdin:

```bash theme={"theme":"css-variables"}
jam create jam @jam.json        # read from a file
cat jam.json | jam create jam   # pipe via stdin
```

Run `jam create jam --help` for both payload shapes, or `jam agent-context` for the full machine-readable JSON Schema (under `create.jam`, on the `source` arg).

Add a comment to a Jam:

```bash theme={"theme":"css-variables"}
jam create comment <jamId> "Logs at 00:42 show a 500 on /checkout." --at 42000
```

`<body>` is Markdown. `--at` pins the comment to a video timestamp in milliseconds.

Rewrite a comment you left earlier:

```bash theme={"theme":"css-variables"}
jam update comment <commentId> "Logs at 00:42 show a 500 on /checkout — fixed in #1423."
```

The new body replaces the old one entirely, and you can only edit comments you authored. `<commentId>` is the `id` the create call returned; the share URL it printed works too.

React to a comment, or take the reaction back:

```bash theme={"theme":"css-variables"}
jam create reaction <commentId> "👀"
jam delete reaction <commentId> "👀"
```

Reactions are one of 🐛 💜 ✅ 👀 ❓ 👏 🔥 👍 — the same set the share page offers. Both commands are idempotent, and removing only clears your own reaction.

Rename a Jam, rewrite its description, or move it to a folder:

```bash theme={"theme":"css-variables"}
jam update jam <id> --title "Checkout fails on Safari"
jam update jam <id> --description "Repro steps are in the console log."
jam update jam <id> --folder <folder-id>
jam update jam <id> --folder ""
```

Pass at least one flag. Only the fields you pass change. Pass an empty string to `--folder` to remove the Jam from its current folder. `--description` takes Markdown, and an `@mention` of a teammate's email notifies them. Editing the title or description needs an Admin or Creator role; moving folders does not.

### Create and rename folders

```bash theme={"theme":"css-variables"}
jam create folder "Checkout bugs"
jam update folder checkout-bugs --name "Checkout"
```

`create folder` returns `{ id, shortId, name }`, so you can file a Jam into the new folder straight away with `jam update jam <id> --folder <shortId>`. Folder names are not unique — run `jam list folders` first if you mean to reuse an existing folder rather than add another one with the same name.

`update folder` accepts a folder name, its short ID, or its UUID. Renaming leaves the folder's Jams and short ID untouched.

### Delete Jams, comments, and folders

```bash theme={"theme":"css-variables"}
jam delete jam <id>
jam delete comment <commentUid>
jam delete folder <folder-id>
```

Archiving a Jam takes it out of your lists and search but keeps the recording, so you can restore it from the dashboard. Deleting a folder archives every Jam inside it and reports how many in `archivedJamCount`. Deleting a comment is permanent and takes its attachments with it — only the comment's author can do it.

Each command asks you to confirm first. Pass `-y` (or `--yes`) to skip the prompt. Scripts and agents have no terminal to answer on, so they must pass `-y`; without it the command refuses rather than assuming an answer.

### Recording links

A recording link is a shareable URL that collects Jams: anyone who opens it can record and submit a Jam back to your workspace. A link captures console and network logs only when it records from a connected recording domain (a "recording URL"), so list your connected domains first and pass one when you create the link. See [Recording Links](/docs/recording-links) for the dashboard workflow.

```bash theme={"theme":"css-variables"}
jam recording-links urls
jam recording-links create --name "Support intake" --recording-url-id <url-id> --folder "Bug reports"
```

`create` returns the link's public ID and shareable URL. Every other command addresses the link by that public ID.

```bash theme={"theme":"css-variables"}
jam recording-links jams <id> --limit 50
jam recording-links update <id> --name "Q3 support intake"
jam recording-links revoke <id>
```

`jams` lists the Jams recorded through a link. `update` edits its settings (name, folder, reference, Jam title, expiration, metadata). `revoke` soft-deletes the link so it stops accepting new recordings, while the Jams it already collected stay. To connect a new domain, run `jam recording-links verify <url>` and open the returned link in a browser where Jam is live on that domain.

## Output mode

The CLI pretty-prints when stdout is a TTY and emits compact JSON when output is piped. Force JSON output in any context with the top-level `--json` flag:

```bash theme={"theme":"css-variables"}
jam --json auth status
jam --json get jam <id> | jq '.title'
```

Machine consumers (agents, scripts) should pass `--json` so output stays parseable regardless of where the command runs.

## Pagination

Paginated commands return:

```json theme={"theme":"css-variables"}
{
  "items": [...],
  "next_cursor": "<opaque>" | null,
  "truncated": true | false,
  "hint": "Use --after=<cursor> to fetch the next page."
}
```

Walk every page in a shell loop:

```bash theme={"theme":"css-variables"}
cursor=""
while :; do
  page=$(jam --json get console "$ID" --limit 500 ${cursor:+--after "$cursor"})
  echo "$page" | jq -c '.items[]'
  cursor=$(echo "$page" | jq -r '.next_cursor // empty')
  [ -z "$cursor" ] && break
done
```

`--limit` caps each page at 500. Defaults: 50 for `get` commands, 20 for `list` commands.

## Exit codes

The exit code is authoritative. Branch on it, not on stderr parsing.

| Code | Name       | When                                                   |
| ---- | ---------- | ------------------------------------------------------ |
| 0    | success    | Command completed.                                     |
| 1    | generic    | Unclassified error.                                    |
| 2    | usage      | Invalid flag or argument.                              |
| 3    | auth       | Not authenticated or token rejected (HTTP 401 or 403). |
| 4    | not\_found | Resource missing (HTTP 404).                           |
| 5    | validation | Enum or integer validation failed.                     |
| 6    | server     | Upstream returned 5xx.                                 |

In JSON mode, errors print to stderr as `{"error":{"code":"...","message":"..."}}`. `valid_values` is included on validation errors when applicable.

## Environment variables

| Variable           | Purpose                                                                                                                            |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| `JAM_TOKEN`        | Bearer token used in place of stored credentials. The CLI uses it for the lifetime of the process and never writes it to disk.     |
| `JAM_NO_TELEMETRY` | Set to `1` to disable all CLI telemetry: lifecycle events (install, update, uninstall) plus per-command usage and error reporting. |

## Update and uninstall

Install the latest CLI binary:

```bash theme={"theme":"css-variables"}
jam upgrade
```

Install a specific version:

```bash theme={"theme":"css-variables"}
jam upgrade --target 0.2.0
```

The CLI verifies the new binary's checksum, runs a `--version` smoke test, and replaces the running binary atomically. On Windows the running `.exe` is locked, so each version installs into its own folder and `jam upgrade` re-points a `jam` command at the new one — a `jam` process you already have open keeps running the old version until you restart it.

Remove the CLI and local data:

```bash theme={"theme":"css-variables"}
jam uninstall
```

Skip the confirmation in non-interactive environments:

```bash theme={"theme":"css-variables"}
jam uninstall --yes
```

Uninstall removes `~/.local/bin/jam`, the `~/.local/state/jam/` state directory, your stored credentials in `~/.config/jam/`, and the `PATH` marker the installer added to your shell rc files. On Windows it removes the `%LOCALAPPDATA%\Programs\Jam` install folder and drops its entry from your user `PATH`.

<Warning>
  `jam uninstall` is irreversible. Re-install via the curl one-liner to recover.
</Warning>

## Use the CLI with AI coding agents

The CLI ships two surfaces for AI coding agents: a bundled skill and a JSON command catalog.

### Bundled skills

`jam skills install` writes the bundled `SKILL.md` into the location your agent runtime expects (Claude Code, Cursor, Codex, OpenCode). The CLI auto-detects the runtime via environment variables, then falls back to project-level marker directories before defaulting to Claude.

```bash theme={"theme":"css-variables"}
jam skills install                  # auto-detect target, user-global install
jam skills install --project        # install into the current repo
jam skills install --target cursor  # explicit target
jam skills path                     # preview destination without writing
jam skills list                     # list bundled skills
```

The skill teaches your agent which command to reach for at each step (read Jam, filter errors, leave a comment) and how to interpret the structured output.

### Machine-readable command surface

`jam agent-context` prints the command surface as JSON: argument types, flag enums, default limits, and output shapes. Pair it with `--json` on every read or write call to keep tool wrappers thin.

```bash theme={"theme":"css-variables"}
jam agent-context | jq '.commands["get.jam"]'
```

The shape is locked by a snapshot test, so the JSON stays stable across releases inside the same `schema_version`.


# ClickUp
Source: https://jam.dev/docs/clickup

Turn every Jam into a ClickUp task with full technical context. Set workspace, folder, and list fields from inside the extension.

Connect Jam to ClickUp to turn every bug capture into a ClickUp task in seconds. All the technical context engineers need is attached automatically so you can skip the manual debug-info gathering.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every ClickUp task

Every ClickUp task created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a ClickUp task from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select ClickUp as the destination">
        In the Jam extension, click **Link you can share** and change the destination to ClickUp.
      </Step>

      <Step title="Authenticate with ClickUp">
        Complete the ClickUp OAuth flow to connect your account.
      </Step>

      <Step title="Configure your ClickUp task">
        Once connected, set up your task from Jam: choose the workspace, folder, list, assignee, and more.
      </Step>

      <Step title="Create the task">
        Click **Create task**. Jam creates the ClickUp task and opens it in a new tab.
      </Step>
    </Steps>

    <Note>
      ClickUp workspace guests can also create Jams. Their Space field defaults to the shared space they have access to, while they can continue filling out other public fields.
    </Note>

    <Tip>
      Click **Edit fields** during task setup to manage which ClickUp fields appear in the Jam extension. Remove fields you don't use to keep the workflow fast.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to ClickUp">
    Create a ClickUp task from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a ClickUp task.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select ClickUp.
      </Step>

      <Step title="Log in to ClickUp if prompted">
        If this is your first time using Jam + ClickUp, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the task details">
        Enter the workspace, folder, list, assignee, and any other fields you need.
      </Step>

      <Step title="Create the task">
        Click **Create task** to send the Jam to ClickUp.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Connect multiple ClickUp workspaces">
    A Jam account or workspace connects to multiple ClickUp workspaces.

    <Steps>
      <Step title="Open Settings → Integrations">
        Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations).
      </Step>

      <Step title="Click ClickUp">
        The ClickUp authentication flow opens in a new tab.
      </Step>

      <Step title="Select the workspaces to connect">
        Select or deselect the ClickUp workspaces you want to connect to. Selected workspaces show a blue circle indicator.
      </Step>

      <Step title="Confirm the connection">
        Click **Connect Workspaces**.
      </Step>

      <Step title="Review connected workspaces">
        After connecting, you'll see which ClickUp workspaces are linked to that Jam workspace.
      </Step>
    </Steps>

    <Warning>
      Make sure to connect all the workspaces you need during this step. You won't be able to see the workspace selection screen again unless you disconnect and reconnect your ClickUp connection. Due to a ClickUp API limitation, ClickUp can only be connected to one Jam account or workspace at a time.
    </Warning>
  </Tab>
</Tabs>


# Company overview
Source: https://jam.dev/docs/company-overview

Read Jam's company story, mission, values, AI policy, and security commitments.

Jam company pages explain who we are, what we build toward, how we use AI, and how we protect customer data.

## About Jam

<CardGroup>
  <Card title="About" icon="building" href="/about">
    Learn when Jam was founded, who uses Jam, and how to contact the team.
  </Card>

  <Card title="Mission" icon="flag" href="/mission">
    Read why Jam exists and what we believe bug reporting should become.
  </Card>

  <Card title="Values" icon="diamonds-4" href="/values">
    See how Jam builds with customers, ships fast, and keeps software simple.
  </Card>
</CardGroup>

## Review policies

<CardGroup>
  <Card title="AI Policy" icon="sparkle" href="/ai-policy">
    See what data Jam AI uses and how third-party model providers handle it.
  </Card>

  <Card title="Security" icon="shield-check" href="/security">
    Review Jam's data protection practices, infrastructure, and compliance details.
  </Card>
</CardGroup>


# Configuration
Source: https://jam.dev/docs/configuration-overview

Configure the Jam SDK, Recording Links, browser access, and debugging defaults for the way your workspace captures bugs.

Jam configuration pages help you tune how Jam runs in your product, browser, and workspace rollout.

## Set up the Jam SDK

<CardGroup>
  <Card title="Custom logs" icon="list-timeline" href="/custom-logs">
    Attach app state, user IDs, and feature flags to every Jam.
  </Card>

  <Card title="Connect Domain" icon="globe" href="/custom-recording-domain">
    Connect your own domain so Recording Links capture console logs and network requests.
  </Card>

  <Card title="Auto-blur" icon="eye-low-vision" href="/auto-blur">
    Hide sensitive content automatically during Recording Link sessions.
  </Card>
</CardGroup>

## Tune browser and rollout settings

<CardGroup>
  <Card title="Site access" icon="shield-keyhole" href="/extension-setup#site-access">
    Limit the Chrome extension to the sites where you want Jam to run.
  </Card>

  <Card title="Auto-deploy" icon="building-circle-check" href="/auto-deploy">
    Install the Chrome extension across your organization with Google Admin Console.
  </Card>

  <Card title="Local files" icon="file" href="/extension-setup#local-files">
    Annotate local JPG, PDF, and HTML files opened in your browser.
  </Card>

  <Card title="AI apps" icon="sparkles" href="/ai-apps">
    Capture prompt, model, and app-state context when debugging AI apps.
  </Card>
</CardGroup>


# Creating a Jam
Source: https://jam.dev/docs/creating-a-jam

Install the Chrome extension or iOS app and share your first bug report in seconds. Every report includes console logs, network requests, and device info.

Jam captures bugs with full technical context (console logs, network requests, user events, and device metadata) automatically attached to every capture. You can capture from your browser with the Chrome extension, from your phone with the iOS app, or collect recordings from someone else with a Recording Link.

## From your browser

<iframe />

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

  <Step title="Pin the extension">
    Pin Jam to your browser toolbar so it's always one click away during testing and debugging.
  </Step>

  <Step title="Create your account">
    Click the Jam icon, enter your email, and set up your account.
  </Step>

  <Step title="Choose a capture method">
    Click the Jam icon in your toolbar and select how you want to capture:

    <Tabs>
      <Tab title="Screenshot">
        <img alt="Jam extension popup with Capture Screenshot highlighted" />

        Captures the current page state with full technical context: console logs, network requests, user events, and device metadata.
      </Tab>

      <Tab title="Video Recording">
        <img alt="Jam extension popup with Record Desktop highlighted and microphone toggled On" />

        Records your screen while you reproduce the issue step-by-step. Includes the same full technical context as a screenshot.
      </Tab>

      <Tab title="Instant Replay">
        <img alt="Jam extension popup with Instant Replay highlighted" />

        Automatically captures up to the last 2 minutes of activity. No need to reproduce the bug. Hit the Jam button after it happens.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Add a description and create">
    Add a description, then click **Create**. Your Jam opens in a new tab with all technical details included, and the link is automatically copied to your clipboard.
  </Step>

  <Step title="Share or file a ticket">
    Paste the Jam link into Slack, a Jira ticket, a GitHub issue, or wherever your team tracks bugs. You can also send it directly to an integration from the Jam share page.
  </Step>
</Steps>

<Tip>
  Use keyboard shortcuts to capture even faster. Open the extension popup or trigger Instant Replay without leaving the page you're debugging. See [keyboard shortcuts](/docs/keyboard-shortcuts) for the full list.
</Tip>

## From your phone

<Info>
  Jam is currently available for iOS only.
</Info>

<iframe />

<Steps>
  <Step title="Install the iOS app">
    [Download](https://apps.apple.com/de/app/jam-fix-bugs-faster/id6469037234?l=en-GB) Jam from the App Store.

    <img alt="QR code that opens Jam for iOS on the App Store" />
  </Step>

  <Step title="Start recording">
    Tap the Jam button and begin a screen broadcast to start capturing.
  </Step>

  <Step title="Reproduce the issue">
    Navigate to your app or website and demonstrate the bug.
  </Step>

  <Step title="Stop and send">
    Stop the broadcast, trim your video, add a description, and send to your issue tracker
  </Step>
</Steps>

## From someone else

To collect a recording from a customer or teammate, create a [Recording Link](/docs/recording-links) and send it to them. They record in their browser with no install or account required, and the recorded Jam appears in your workspace.


# Custom logs
Source: https://jam.dev/docs/custom-logs

Attach live debug data like user IDs, app state, and feature flags to every Jam automatically with `jam.metadata()`.

<img alt="Jam Info panel showing Custom fields with User ID, WorkspaceID, and FeatureFlags values attached to the capture" />

<iframe />

A single `jam.metadata()` call ensures every Jam submitted from your website includes the metadata you need to debug. Custom logs work on all types of Jams, including requested Jams from Recording Links, Jam for Customer Support, and the Jam browser extension.

You can log anything: static values like `userId` and `teamId`, or live data from Redux and React state. Add what you need to debug, and it appears in every Jam.

## Installation

Install the Jam SDK into your project:

<Tabs>
  <Tab title="npm">
    ```bash theme={"theme":"css-variables"}
    npm install '@jam.dev/sdk'
    ```
  </Tab>

  <Tab title="yarn">
    ```bash theme={"theme":"css-variables"}
    yarn add '@jam.dev/sdk'
    ```
  </Tab>
</Tabs>

## Usage

Call `jam.metadata()` once at the root of your app, in the same place you initialize your stores and render your root element. The callback you pass is invoked each time a Jam is captured, so the data is always live and never stale.

```javascript theme={"theme":"css-variables"}
import { jam } from "@jam.dev/sdk";

jam.metadata(() => {
  return {
    userId: 5492,
    workspaceId: 'd3b59ce8-95f1-410c-bb5e-9dc598599336',
    timeSincePageLoad: performance.now(),
    // and any other debug data you'd need
  };
});
```

Once configured, your metadata appears inside every Jam filed from your site.

## What data you can include

Beyond static values and local variables, you can pass in:

* **App store state**: user ID, workspace ID, the last 5 items in a checkout cart, which feature flags are enabled, and so on.
* **localStorage values**: any values stored locally in the browser.
* **Any serializable data**: whatever you need to reproduce or understand the bug.

## When is metadata captured?

Metadata is captured at the moment the bug reporter creates a Jam. Because the function you pass to `jam.metadata()` is called at capture time, the data reflects the live state of your app, not a stale snapshot from when the page loaded.

## Limits and constraints

When calling `jam.metadata()`, the returned object must meet all of the following requirements:

1. **Must be an `Object` instance**: for example, `{ a: 1, b: 2 }`. Passing `window` (a `Window` instance) will not work.
2. **Under 10 KB** when serialized.
3. **Serializable**: if `JSON.stringify` cannot stringify it, Jam cannot store it.

## Error handling

If your app throws an error, or any of the above constraints are not met, Jam will:

* Log the error in your browser's live console.
* Display an error message when the Jam is captured.

<Warning>
  If `jam.metadata()` throws or returns an invalid value, the Jam is still created, but without your custom metadata. Check your browser console if you expect metadata and don't see it in a Jam.
</Warning>


# Connect your domain
Source: https://jam.dev/docs/custom-recording-domain

Connect your own domain to Recording Links so console logs and network requests get captured from every customer recording.

Connecting your domain ties your website or web app to Jam so Recording Links capture console logs, network requests, and user interactions alongside the screen recording. Without a connected domain, screen recordings still work, but developer logs aren't included.

A connected domain lets Jam:

* Serve Recording Links from your own domain, so links look branded and familiar to your customers.
* Capture console logs and network requests on every recording.
* Attach developer logs directly to Jams.
* Auto-blur sensitive fields like passwords and payment details while recording.

You need write access to your site to complete the steps below.

<Note>
  Every snippet on this page has a runnable example in the [recording-links-demos](https://github.com/jamdotdev/recording-links-demos) repo, including HTML, Next.js, Angular, and Google Tag Manager.
</Note>

## Setup

<Steps>
  <Step title="Install the code snippets">
    Open [**Settings → Jam SDK**](https://jam.dev/s/settings/sdk) and pick your framework. The snippet there has your Team ID filled in, and the picker keeps your selection in the address bar (for example, `?framework=angular`), so you can share a link that opens on the right snippet.

    <Frame>
      <img alt="Connect Domain step with framework options HTML, Next.js, Angular, GTM, and Other" />
    </Frame>

    <Tip>
      Next to each snippet, click **Copy agent prompt** to get an install instruction with your Team ID and snippet filled in. Paste it into an AI coding agent like Claude Code or Cursor, and the agent installs the scripts for you.
    </Tip>

    Jam's Recorder and Capture scripts must be served from the **same origin** as your site so recordings and logs are correctly associated. Find your Team ID in [**Settings → Jam SDK**](https://jam.dev/s/settings/sdk), then install the snippet for your framework on all pages, or at minimum on the URL that hosts your recording route.

    <Tabs>
      <Tab title="HTML">
        Paste this into the `<head>` of every page.

        ```html theme={"theme":"css-variables"}
        <meta name="jam:team" content="your-team-id" />
        <script type="module" src="https://js.jam.dev/recorder.js"></script>
        <script type="module" src="https://js.jam.dev/capture.js"></script>
        ```
      </Tab>

      <Tab title="Next.js">
        Use `next/script` with `strategy="beforeInteractive"`. Place the snippet in the **root** layout, not a nested route layout, since `beforeInteractive` is only honored from the root.

        <CodeGroup>
          ```tsx app/layout.tsx (App Router) theme={"theme":"css-variables"}
          import Script from "next/script";

          export default function RootLayout({ children }: { children: React.ReactNode }) {
            return (
              <html lang="en">
                <head>
                  <meta name="jam:team" content="your-team-id" />
                </head>
                <body>
                  <Script
                    src="https://js.jam.dev/recorder.js"
                    type="module"
                    strategy="beforeInteractive"
                  />
                  <Script
                    src="https://js.jam.dev/capture.js"
                    type="module"
                    strategy="beforeInteractive"
                  />
                  {children}
                </body>
              </html>
            );
          }
          ```

          ```tsx pages/_document.tsx (Pages Router) theme={"theme":"css-variables"}
          import { Html, Head, Main, NextScript } from "next/document";
          import Script from "next/script";

          export default function Document() {
            return (
              <Html lang="en">
                <Head>
                  <meta name="jam:team" content="your-team-id" />
                </Head>
                <body>
                  <Script
                    src="https://js.jam.dev/recorder.js"
                    type="module"
                    strategy="beforeInteractive"
                  />
                  <Script
                    src="https://js.jam.dev/capture.js"
                    type="module"
                    strategy="beforeInteractive"
                  />
                  <Main />
                  <NextScript />
                </body>
              </Html>
            );
          }
          ```
        </CodeGroup>
      </Tab>

      <Tab title="Angular">
        Install the package, then initialize it once from your root component. Wrap the call in `ngZone.runOutsideAngular` so the SDK's listeners don't trigger change detection.

        ```bash theme={"theme":"css-variables"}
        npm install @jam.dev/recording-links
        ```

        ```ts theme={"theme":"css-variables"}
        import { Component, OnInit, NgZone } from '@angular/core';
        import * as jam from '@jam.dev/recording-links/sdk';

        @Component({ selector: 'app-root', template: '<router-outlet></router-outlet>' })
        export class AppComponent implements OnInit {
          constructor(private ngZone: NgZone) {}
          ngOnInit() {
            this.ngZone.runOutsideAngular(() => {
              jam.initialize({ teamId: 'your-team-id' });
            });
          }
        }
        ```

        With the SDK, the recorder loads lazily. The recorder and capture scripts download only when someone opens a page through a Recording Link, so `window.jam` won't exist on a normal page view.
      </Tab>

      <Tab title="Google Tag Manager">
        Create a **Custom HTML** tag that fires on **All Pages**, and paste this in. It loads the same Recorder and Capture scripts as the other methods, with a guard so it runs once per page.

        ```html theme={"theme":"css-variables"}
        <meta name="jam:team" content="your-team-id">
        <script>
        (function () {
          if (window.jam) return;
          var sources = [
            "https://js.jam.dev/recorder.js",
            "https://js.jam.dev/capture.js"
          ];
          for (var i = 0; i < sources.length; i++) {
            var script = document.createElement("script");
            script.type = "module";
            script.src = sources[i];
            document.head.appendChild(script);
          }
        })();
        </script>
        ```

        <Note>
          GTM compiles Custom HTML tags as ES5, so it rejects `async`/`await` and dynamic `import()` with errors like *"async function requires ECMASCRIPT\_2017."* This snippet stays ES5 and injects the scripts as DOM elements, which avoids those errors.
        </Note>
      </Tab>
    </Tabs>

    **What each script does:**

    * **`recorder.js`** shows the recording interface when a Recording Link is opened, and lets users record directly from your site.
    * **`capture.js`** captures console logs, network requests, and click and key interactions while a recording is in progress.

    To serve one page to more than one workspace, add a `jam:team` meta tag per workspace.

    <Warning>
      Wait for both scripts to load successfully on your target URL before verifying your domain. Check that your Content Security Policy isn't blocking them.
    </Warning>

    **Performance note:** Jam caches assets aggressively to reduce load. For the plain HTML snippet, place the `<script>` tags as early as possible in `<head>`. Loading them with `async`, `defer`, or lazy `import()` can skip early logs and requests. The Next.js `beforeInteractive` strategy and the SDK handle this for you.
  </Step>

  <Step title="Update your Content Security Policy (if applicable)">
    If your site doesn't define any Content Security Policy directives, skip this step.

    If your site sets a CSP with `frame-src` or `script-src`, add `*.jam.dev` to both. Otherwise the Jam scripts are blocked.

    ```html theme={"theme":"css-variables"}
    <meta
      http-equiv="Content-Security-Policy"
      content="frame-src 'self' *.jam.dev; script-src 'self' *.jam.dev;"
    />
    ```
  </Step>

  <Step title="Verify your domain">
    After installing the scripts, verify your domain so Jam confirms they load and run correctly.

    1. Go to [**Settings → Jam SDK**](https://jam.dev/s/settings/sdk).
    2. Under **Verify domain**, paste the URL where the scripts are installed (for example, `example.com` or `example.com/recorder`).
    3. Click **Verify**.

    Jam opens your URL and checks that:

    * The page is publicly accessible.
    * The URL doesn't redirect.
    * Query parameters are preserved.
    * Both the Recorder and Capture scripts are installed with a matching Team ID.

    On success, Jam confirms with a **Domain successfully verified** toast, the domain appears under **Connect Domain** marked **Installed**, and Recording Links from that domain capture console logs and network requests.

    <Warning>
      If your app redirects users from the recording URL (for example, sending unauthenticated users to a login page) keep all `jam-` query parameters through the redirect. The most important is `jam-recording=...`. Open your recording URL in an incognito window before verifying to check for unexpected redirects or parameter stripping.
    </Warning>
  </Step>
</Steps>

## Check your connection status

Jam shows your connection status in two places, so you can tell at a glance whether a recording will capture logs:

* **The Recording Links header**: the globe button carries a status dot. Red means no domain is connected yet, and clicking it starts setup. Green means at least one domain is connected, and hovering shows which one.
* **The domain picker when you create a Recording Link**: each domain under **Start recording from** shows a dot. Green means **Log capture enabled** (the domain is verified). Red means **Log capture disabled**. The default `recorder.jam.dev` records fine, but can't capture your site's logs, so it always shows red. **Connect your domain** at the bottom of the dropdown starts setup for another domain.

## Connect more than one domain

Once your first domain is verified, open [**Settings → Jam SDK**](https://jam.dev/s/settings/sdk) and click **Add another domain** to connect the next site to the same workspace. This opens the same install and verify steps. Each connected domain appears in the list marked **Installed**, and shows up in the domain picker when you create a Recording Link.

## Domain and subdomain behavior

In most cases, a recorder installed on the root domain (`example.com`) can capture events from subdomains (`sub.example.com`), and vice versa.

**Safari limitation:** In Safari, logs are only captured when the recorder and capture scripts run on the exact same subdomain. If Safari support is important for your team, install the recorder on the same subdomain where your users are active.

## Current limitations

| Limitation                | Details                                                                                                                                                             |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Browser support**       | Fully supported in Chrome (including Incognito) and Firefox (including Private Windows). Supported in most Safari windows. Not supported in Safari Private Windows. |
| **Iframes**               | If the Capture script is installed inside an iframe, top-level page logs are not captured.                                                                          |
| **Script loading**        | Scripts loaded with `async`, `defer`, or lazy `import()` may miss early console logs and network requests.                                                          |
| **Verification required** | Installing scripts alone is not enough. You must verify your domain in [**Settings → Jam SDK**](https://jam.dev/s/settings/sdk).                                    |

## FAQ

<AccordionGroup>
  <Accordion title="Can I put the Recorder and Capture scripts on different pages?">
    Yes. The `<meta name="jam:team" />` tag must be present on any page where `recorder.js` is installed. It's optional on pages that only include `capture.js`. Logs are only captured from pages where the Capture script is running.
  </Accordion>

  <Accordion title="Can I programmatically create Recording Links?">
    Not yet. Jam plans to expose an API for creating Recording Links programmatically (for example, from Slack, Zendesk, or directly within your app).
  </Accordion>

  <Accordion title="Can I customize the recorder UI?">
    Not currently. Contact Jam if you have specific customization requirements.
  </Accordion>

  <Accordion title="Can I mix Jam recordings with my own recording infrastructure?">
    No. Jam's Recorder and Capture scripts must be used together. Due to browser storage and cross-origin restrictions, partial integrations or mixing with external recording systems are not supported.
  </Accordion>
</AccordionGroup>

## If verification fails

When Jam can't find the scripts on your URL, verification stops with **Scripts not detected. Ensure both code snippets are installed here and try again.** Common causes:

* Team ID mismatch
* Scripts not installed on the target URL
* Scripts blocked by your CSP
* URL requires authentication
* URL redirects before scripts load
* Query parameters stripped during redirect
* Recorder and Capture scripts on different domains

Fix the issue and retry verification.


# Delete your account
Source: https://jam.dev/docs/delete-account

Delete your Jam account from Settings and see what happens to your Jams, workspaces, comments, and subscriptions before you confirm.

Delete your Jam account yourself from [**Settings**](https://jam.dev/s/settings/account), no support ticket needed. Deletion takes effect immediately and also removes every workspace where you're the only member.

<Warning>
  Account deletion is permanent. Jam cannot restore your account, your Jams, or your workspaces after you confirm.
</Warning>

## What happens to your data

What gets deleted depends on whether you share each workspace with other members.

### Workspaces where you're the only member

* **The workspace**: deleted permanently, along with its folders and settings.
* **Your Jams, recording links, and comments**: deleted permanently.
* **The subscription**: canceled automatically if the workspace has one.

### Shared workspaces

* **Your membership**: removed. The workspace and its other members are unaffected.
* **Jams and recording links you created**: stay in the workspace, so your team keeps its bug reports.
* **Your comments**: stay on their Jams, attributed to **Deleted account**.
* **Billing**: if you manage the workspace's subscription, billing transfers to another Admin automatically.

<Note>
  Jam keeps the content you created in shared workspaces. To have that content permanently deleted as well, contact [Jam support](https://jam.dev/help).
</Note>

## Before you delete

* **Save anything you want to keep.** Deleted Jams and workspaces cannot be recovered.
* **Hand off workspaces you administer.** If you're the only Admin of a workspace with other members, assign another [Admin](/docs/members-and-roles) in [**Settings → Members**](https://jam.dev/s/settings/members) first. Jam blocks deletion and links you to the right page until every shared workspace has another Admin.
* **Check whether your company manages your account.** If any of your workspaces uses Single Sign-On (SSO) or Directory Sync, your account is managed through your company's identity provider and the delete option doesn't appear. Contact your workspace Admin or [Jam support](https://jam.dev/help).

## Delete your account

<Steps>
  <Step title="Open your account settings">
    Go to [**Settings → Account**](https://jam.dev/s/settings/account).
  </Step>

  <Step title="Click Delete">
    Scroll to the **Delete account** section and click **Delete**.
  </Step>

  <Step title="Review what gets deleted">
    The confirmation dialog lists every workspace that will be deleted with your account, along with its plan.
  </Step>

  <Step title="Type DELETE to confirm">
    Type **DELETE** in the confirmation field. The confirmation is case sensitive.
  </Step>

  <Step title="Click Delete account">
    If the deletion includes workspaces, the button also counts them. Jam deletes your account and signs you out immediately.
  </Step>
</Steps>


# DevTools
Source: https://jam.dev/docs/devtools

Inspect console logs, network requests, user events, and device info inside every Jam. The same toolkit engineers use in the browser.

Every Jam automatically captures the technical data engineers expect from the browser's own developer tools: console logs, network data, and environment details. No setup or configuration required. You can capture additional metadata with [Custom logs](/docs/custom-logs).

## Console logs

Every Jam records the console output from the captured page, with a severity filter to show only errors, warnings, or specific log levels.

<Frame>
  <img alt="Console tab in a Jam showing captured logs with severity filters" title="Console tab" />
</Frame>

## Network requests

Jam captures request and response details, including bodies, for all XHR and fetch requests on the page. Each request includes complete timing breakdowns (DNS lookup, connection time, and response duration), matching the data engineers expect from Chrome DevTools.

### GraphQL

GraphQL returns a 200 status code even when the response body contains errors, and it typically routes every operation through a single `/graphql` endpoint. That normally means combing through each request to find the failure.

Jam handles both problems automatically:

* **Error detection:** Jam flags GraphQL responses that contain errors in the response body, even though they return HTTP 200.
* **Operation names:** Jam detects and shows the GraphQL operation name directly in the request list, so you can identify specific queries and mutations without clicking into each request.

### When bodies are missing

A few edge cases prevent Jam from capturing the request or response body:

* **Timing:** the request happened before Jam was initialized on the page. This depends on when your application's scripts load compared to Jam's.
* **CORS:** the browser performed a preflighted OPTIONS check that did not pass, so the request body was never sent.
* **Static assets:** images, scripts, and other non-programmatic assets (anything that is not XHR, fetch, or WebSockets) are not captured.

### Secrets and redaction

<Frame>
  <img alt="Network request inspector showing JAM_DOES_NOT_SAVE_SECRETS in place of access-control-allow header values" />
</Frame>

We understand sensitive information can be present in network requests, which is why Jam scans all network requests for any possible sensitive information including tokens, cookies and PII. We filter out these fields on the client side so they never reach Jam's servers.

We remove any potentially sensitive fields from request headers, and (if in JSON), request bodies. This is done prior to Jam creation, so the Jam data you see on the page (with the `JAM_DOES_NOT_SAVE_SECRETS` strings as the values of these headers) has already been filtered before leaving your laptop. It does not reach Jam's servers.

In the resulting Jam, you will see `JAM_DOES_NOT_SAVE_SECRETS` in place of any possible secret information.

We prefer to over-filter than under-filter and are taking the route of being overly cautious, so sometimes you will see information filtered out that probably should not have been. Help us improve our filtering accuracy by sending your feedback to [hello@jam.dev](mailto:hello@jam.dev).

### Binary payloads

When a request or response body contains binary content (Protocol Buffers, WebSocket binary frames, MessagePack, gRPC payloads, or other non-text formats), Jam displays a placeholder instead of the raw data:

```text theme={"theme":"css-variables"}
[binary: 474 bytes]
```

The placeholder tells you the data is binary and how large the payload is in bytes. Use the content length to verify whether the expected amount of data is being sent and received. To inspect the actual payload, use your browser's native DevTools alongside Jam to decode the data with format-specific tools.

## FAQs

<AccordionGroup>
  <Accordion title="Do I need to enable DevTools manually?">
    For Jams captured with the browser extension, DevTools data is captured automatically with no setup required. Jams submitted through a [Recording Link](/docs/recording-links) capture screen recordings only by default. To also collect console logs and network requests, [connect your domain](/docs/custom-recording-domain) and install Jam's scripts on your site.
  </Accordion>
</AccordionGroup>


# Setup and configuration
Source: https://jam.dev/docs/extension-setup

Set up the Jam extension and control where it runs: specific sites, local files, and incognito windows.

Install the Jam extension once, then control exactly where it runs: every site or just a few, local files, and incognito windows.

## Install the extension

Install Jam from the [Chrome Web Store](https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci). The same extension works across all supported Chromium browsers. See [Browser support](/docs/browser-support) for the full compatibility list.

After installing, pin Jam to your browser toolbar so it's always one click away.

## Site access

By default, Jam runs on all websites. To restrict it:

<Steps>
  <Step title="Open Chrome extensions">
    Enter `chrome://extensions` in your URL bar and press Enter.
  </Step>

  <Step title="Open the Jam extension details">
    Click **Details** for the Jam extension.
  </Step>

  <Step title="Switch to specific-site access">
    Under **Site access**, change from **On all sites** to **On specific sites**.
  </Step>

  <Step title="Add the Jam domain">
    Add `https://*.jam.dev/*` and click **Add**.
  </Step>

  <Step title="Add any other URLs you want Jam to run on">
    Use **Add a new page** to include additional websites.
  </Step>

  <Step title="Re-enable on all sites later">
    To re-enable Jam everywhere, change **Site access** back to **On all sites**.
  </Step>
</Steps>

## Local files

Annotate and share feedback on any file type (JPG, PDF, HTML) by opening it in your browser.

<Steps>
  <Step title="Open Chrome extensions">
    Enter `chrome://extensions` in your URL bar.
  </Step>

  <Step title="Open the Jam extension details">
    Click **Details** for Jam.
  </Step>

  <Step title="Enable access to file URLs">
    Under **Allow access to file URLs**, enable the toggle.
  </Step>
</Steps>

## Incognito sessions

Jam works seamlessly in incognito mode, giving you complete debugging capabilities while maintaining privacy. Perfect for internal testing, sensitive environments, or when you need to capture bugs without leaving traces in your regular browsing session.

<Tabs>
  <Tab title="Chrome">
    **Enable Incognito Access in Chrome**

    1. Go to `chrome://extensions` in your address bar
    2. Find the Jam extension
    3. Click Details
    4. Toggle on **Allow in incognito**
  </Tab>

  <Tab title="Edge">
    **Enable Incognito Access in Edge**

    1. Go to `edge://extensions` in your address bar
    2. Find the Jam extension
    3. Click Details
    4. Toggle on **Allow in InPrivate**
  </Tab>
</Tabs>

### Incognito FAQs

<AccordionGroup>
  <Accordion title="Does incognito mode affect the quality of bug reports?">
    No. You get the same data collection in incognito mode, including full network logs, console output, and device information.
  </Accordion>

  <Accordion title="Can I use Jam in incognito mode without enabling this setting?">
    No. Browser security policies require explicit permission for extensions to run in private browsing modes.
  </Accordion>

  <Accordion title="Will my incognito browsing data be saved in Jam reports?">
    Jam only captures the specific page and interactions you choose to record. Your broader incognito browsing session remains private.
  </Accordion>
</AccordionGroup>


# Fin AI Agent
Source: https://jam.dev/docs/fin-ai-setup

Add Jam as a step inside your Fin AI workflow so customers submit a recording automatically at the right moment.

## Requirements

* This is a feature for paid plans
* Jam Intercom App installed in the Intercom workspace
* Web channel only (mobile not supported)
* Fin workflow configuration required

## How the integration works

The integration works by adding the Jam Intercom App directly to your Fin workflows, allowing you to prompt users for screen recordings at specific points in your customer support process.

## Adding Jam to your Fin workflow

You can add Jam as a step to prompt customers for screen recordings at the right moment in the conversation.

### Step 1: Access Your Fin Workflow

Navigate to your Fin workflow where you want to add Jam integration.

### Step 2: Set Channel to Web

Ensure your workflow channel is set to "Web".

<Info>
  Jam for Intercom currently doesn't support mobile devices. Make sure to set your workflow channel to Web.
</Info>

### Step 3: Add Jam Step

<Steps>
  <Step title="Add a step">
    Click **Add step**.
  </Step>

  <Step title="Select Send an app">
    Choose **Send an app**.
  </Step>

  <Step title="Choose Jam">
    Pick **Jam** from the list of available apps.
  </Step>

  <Step title="Configure fields">
    * **Message**: the standard message that will accompany every Jam link.
    * **Opt out**: Check **Yes** to offer customers a choice between recording a Jam and providing text detail.

    <Info>
      Only select **Yes** if you plan to configure Jam with webhooks. Otherwise, this setting has no impact.
    </Info>
  </Step>

  <Step title="Add the app to the workflow">
    Click **Request screen recording**.
  </Step>
</Steps>

## (Optional): Configure webhooks for more control

By default, Intercom doesn't know whether a customer recorded a Jam or opted out. If you want to branch your workflow based on the customer's choice, you can configure webhooks.

### 1. Add Wait for Webhook

After the Jam step, click Add step → Wait for Webhook.

Edit the example text:

* Replace `example_key` with `event`.
* Replace the example value with `intercom.recorder.opted_out`.
* Add `payload` inside `data` with empty curly brackets `{}`.

Full example:

```json theme={"theme":"css-variables"}
{
  "event": "some string",
  "payload": {}
}
```

Copy the Webhook URL (everything except "/\<Conversation ID>").

<Warning>
  The above webhook will only apply to this specific Intercom Workflow. You will need to set up a separate webhook for each Workflow you create.
</Warning>

### 2. Register the Webhook in Jam

Follow the instructions in the [Jam Webhooks documentation](/docs/webhooks) to configure your endpoint.

### 3. Add Branching Logic

Under the Wait for Webhook step, Add Step → Branches.

Create two branches:

* **Branch 1:** event Is "intercom.recorder.recorded"
* **Branch 2:** event Is "intercom.recorder.opted\_out"

## Design what happens after Jam

* If the customer recorded a Jam: assign a team member to review
* If the customer opted out: ask them to explain the issue via text

## Current limitations

Jam for Intercom can only be activated with Fin Workflows. Integration via Fin Tasks is currently not possible.


# Fin (fka Intercom)
Source: https://jam.dev/docs/fin-intercom-setup

Request screen recordings from customers inside Fin conversations and get the full technical context back in the thread.

<iframe />

Jam for Fin lets your support agents request screen recordings directly from Fin conversations. Agents send a recording request in one click. The customer records without installing anything, and the resulting Jam (a screen recording plus optional technical logs) appears as a note in the conversation and in your Jam dashboard.

Jam supports **Intercom Messenger**, **email**, and **Slack** channels.

***

## Connect Fin with Jam

<Steps>
  <Step title="Open Settings → Integrations">
    Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations).
  </Step>

  <Step title="Select Fin">
    Click **Fin** and complete the authorization flow.
  </Step>

  <Step title="Confirm connection">
    Once authorized, Jam becomes available inside your Intercom inbox.
  </Step>
</Steps>

***

## Set up Jam in the Intercom sidebar

Pin Jam to the top of the Intercom sidebar so agents can request recordings without switching tools:

<Steps>
  <Step title="Open the Intercom inbox">
    Navigate to any conversation in your Intercom inbox.
  </Step>

  <Step title="Edit sidebar apps">
    Scroll to the bottom of the sidebar and click **Edit apps**.
  </Step>

  <Step title="Pin Jam">
    Find Jam in the list, pin it, and drag it to the top of the sidebar.
  </Step>
</Steps>

***

## Request a Jam from Fin

<Steps>
  <Step title="Open the conversation">
    Navigate to the customer conversation where you need a recording.
  </Step>

  <Step title="Click the Jam app">
    Select Jam from the sidebar or use an Intercom shortcut.
  </Step>

  <Step title="Send the recording request">
    Click to send. Jam sends the customer a message with a recording link.
  </Step>
</Steps>

<Note>
  In email and Slack conversations, the Jam app cannot render inside the thread. In those cases, Jam sends the customer a direct Recording Link instead.
</Note>

### What the customer sees

* A message asking them to record their screen
* A link that opens the Jam recorder in their browser
* A simple interface to start recording
* Automatic upload on submission

### What the agent sees

After the customer submits:

* A note added to the Fin conversation
* A link to the Jam recording, which includes:
  * Screen recording
  * System metadata
  * Console logs and network requests (if your domain is connected)
  * Custom logs such as user IDs (if configured)

***

## Jam Inbox for Fin

After connecting Fin, a dedicated **Jam for Fin** page appears in your Jam dashboard. This works as a centralized inbox for all recordings requested through Fin.

From the inbox you can:

* View all Fin-requested Jams
* See which member requested each recording
* Filter and organize submissions
* Access conversation context

***

## Configure default settings

In the top-right corner of the **Jam for Fin** page, you'll find the configuration panel. Changes here apply to all agents by default. Agents can override any setting when sending a request.

### Capture Logs URL

This setting controls where the customer is redirected to record and where logs are captured from.

* If no domain is selected, screen recordings still work but console logs and network requests are not included.
* To enable log capture, install Jam's scripts on your site and verify your domain in [**Settings → SDK**](https://jam.dev/s/settings/sdk).

<Note>
  See [Connect your domain](/docs/custom-recording-domain) for the full setup guide.
</Note>

### Default folder

Choose the folder where Fin Jams are saved. This keeps support recordings separate from internal bug reports and maintains structured triage.

### Default message

Customize the message sent when requesting a recording. The default is:

> "Would you mind taking a screen recording of the issue to send along to our engineers?"

Edit this to match your support tone. Agents can also edit the message before sending each request.

***

## Fin AI Agent integration

For Fin AI workflow integration, see [Fin AI](/docs/fin-ai-setup).

***

## Privacy and data protection

Jam automatically blurs sensitive information in the browser before the recording is uploaded. This applies to all Fin-requested recordings. Blurred data includes password fields, credit card numbers, social security numbers, email addresses, and API keys.

If you use Jam on your own domain, you can further customize blur behavior. See [Auto-blur sensitive content in requested Jams](/docs/recording-links#privacy-and-automatic-blurring).

***

## FAQ

<AccordionGroup>
  <Accordion title="Does Jam work in email and Slack conversations?">
    Yes. In Messenger conversations, the Jam app renders directly inside Intercom. In email and Slack threads, Jam sends the customer a Recording Link instead, since the app cannot render inside those channels.
  </Accordion>

  <Accordion title="Where do Fin recordings appear?">
    Recordings appear as a note inside the Fin conversation, in your Jam dashboard, and in the Jam for Fin inbox view.
  </Accordion>

  <Accordion title="Can agents override the default settings?">
    Yes. Agents can override the Capture Logs URL, Default Folder, and Default Message when sending a recording request.
  </Accordion>

  <Accordion title="Why are console logs missing from my Fin Jam?">
    Console logs are only captured if your domain is connected, Jam's Recorder and Capture scripts are installed, and the verified domain is selected in the Fin settings. If no domain is selected, only the screen recording is captured.
  </Accordion>

  <Accordion title="Is sensitive information protected?">
    Yes. Jam automatically blurs sensitive data in the browser before upload. If you connect your domain, you can further customize blur behavior.
  </Accordion>

  <Accordion title="Can Jam be used with Fin Tasks?">
    No. Jam for Fin currently only supports Fin Workflows. Integration via Fin Tasks is not available.
  </Accordion>
</AccordionGroup>


# Request Customer Screen Recordings from Freshdesk
Source: https://jam.dev/docs/freshdesk

Request screen recordings from customers inside Freshdesk tickets and keep each Jam tied to the original conversation.

Jam works with Freshdesk through Recording Links, shareable URLs you generate in the Jam browser extension and paste directly into a ticket reply. When the customer clicks the link and records, the resulting Jam arrives in your dashboard with a reference back to the original Freshdesk ticket.

## How to request a Jam from Freshdesk

<Steps>
  <Step title="Create a Recording Link">
    Open the Jam browser extension and click **Request a Recording**.
  </Step>

  <Step title="Paste the ticket URL as the link name">
    Copy the Freshdesk ticket URL (e.g., `https://yourcompany.freshdesk.com/agent/tickets/125324`) and paste it into the Recording Link name field. This creates a reference between the Jam and the ticket for easy lookup later.
  </Step>

  <Step title="Generate the link">
    Click **Create link**. The link is automatically copied to your clipboard.
  </Step>

  <Step title="Share the link in the ticket">
    Paste the Recording Link into your Freshdesk ticket reply and send it to the customer.
  </Step>

  <Step title="Receive the recording">
    When the customer records and submits, you receive an email notification. The Jam appears in your dashboard with a reference to the Freshdesk ticket.
  </Step>
</Steps>

***

## What customers experience

The recording flow requires no downloads or account:

1. The customer clicks the Recording Link and it opens directly in their browser.
2. They click **Start Recording** and capture the issue on screen.
3. The recording uploads automatically and you are notified immediately.

***

## What data is collected

Each Jam submitted through a Recording Link includes:

* **Screen recording**: a video of the customer's screen
* **System metadata**: browser version, operating system, screen resolution
* **Reference URL**: the Freshdesk ticket URL you attached when creating the link

<Note>Console logs and network requests are not captured by default. To collect them, connect your domain. See [Connect your domain](/docs/custom-recording-domain).</Note>

***

## Tips for Freshdesk workflows

<Tip>Create a reusable Recording Link and save it as a Freshdesk canned response. Agents can insert it into any ticket reply with a single click, without generating a new link each time.</Tip>

Use the `jam-reference` URL parameter to automatically attach the ticket URL to every Jam from a reusable link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-reference=https%3A%2F%2Fyourcompany.freshdesk.com%2Fagent%2Ftickets%2F125324
```

<Tip>Use the `jam-folder` parameter to route all Freshdesk-requested recordings into a dedicated folder in your Jam dashboard, keeping support Jams separate from internal bug reports.</Tip>


# GitHub
Source: https://jam.dev/docs/github

Turn every Jam into a GitHub Issue with full technical context. Set repo, assignees, and labels from inside the extension.

<iframe />

Connect Jam to GitHub so that every bug you capture becomes a GitHub Issue with full debug context already attached. Engineers get the information they need to reproduce the bug without any back-and-forth.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every GitHub issue

Every GitHub issue created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a GitHub issue from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select GitHub as the destination">
        In the Jam extension, click **Link you can share** and change the destination to GitHub.
      </Step>

      <Step title="Authenticate with GitHub">
        Complete the GitHub OAuth flow to connect your account.
      </Step>

      <Step title="Configure your GitHub issue">
        Once connected, set up your issue from Jam: choose the repository, assignees, labels, milestone, and more.
      </Step>

      <Step title="Create the issue">
        Click **Create issue**. Jam creates the GitHub issue and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during issue setup to control which GitHub fields appear in the Jam extension. Remove fields you don't need to keep the process quick.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to GitHub">
    Create a GitHub issue from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a GitHub issue.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select GitHub.
      </Step>

      <Step title="Log in to GitHub if prompted">
        If this is your first time using Jam + GitHub, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the issue details">
        Enter the repository, assignees, labels, milestone, and any other fields you need.
      </Step>

      <Step title="Create the issue">
        Click **Create issue** to send the Jam to GitHub.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# GitLab
Source: https://jam.dev/docs/gitlab

Turn every Jam into a GitLab issue with full technical context. Set project, labels, and milestones from inside the extension.

Connect Jam to GitLab so that every bug you capture becomes a GitLab issue with all the technical context engineers need already attached. Stop copying and pasting debug information. Jam handles it automatically.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every GitLab issue

Every GitLab issue created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a GitLab issue from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select GitLab as the destination">
        In the Jam extension, click **Link you can share** and change the destination to GitLab.
      </Step>

      <Step title="Authenticate with GitLab">
        Complete the GitLab OAuth flow to connect your account.
      </Step>

      <Step title="Configure your GitLab issue">
        Once connected, set up your issue from Jam: choose the project, assignee, labels, due date, milestones, and more.
      </Step>

      <Step title="Create the issue">
        Click **Create issue**. Jam creates the GitLab issue and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during issue setup to manage which GitLab fields appear in the Jam extension. Hide fields you don't use to keep the workflow fast.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to GitLab">
    Create a GitLab issue from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a GitLab issue.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select GitLab.
      </Step>

      <Step title="Log in to GitLab if prompted">
        If this is your first time using Jam + GitLab, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the issue details">
        Enter the repository, assignees, labels, milestone, and any other fields you need.
      </Step>

      <Step title="Create the issue">
        Click **Create issue** to send the Jam to GitLab.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Request Customer Screen Recordings from HubSpot
Source: https://jam.dev/docs/hubspot

Request screen recordings from customers inside HubSpot conversations and keep each Jam tied to the original thread.

Jam works with HubSpot through Recording Links, shareable URLs you generate in the Jam browser extension and paste directly into a ticket or conversation reply. When the customer clicks the link and records, the resulting Jam arrives in your dashboard with a reference back to the original HubSpot conversation.

## How to request a Jam from HubSpot

<Steps>
  <Step title="Create a Recording Link">
    Open the Jam browser extension and click **Request a Recording**.
  </Step>

  <Step title="Paste the conversation URL as the link name">
    Copy the HubSpot ticket or conversation URL (e.g., `https://yourcompany.hubspot.com/agent/tickets/125324`) and paste it into the Recording Link name field. This links the Jam back to the HubSpot conversation for easy reference.
  </Step>

  <Step title="Generate the link">
    Click **Create link**. The link is automatically copied to your clipboard.
  </Step>

  <Step title="Share the link in the conversation">
    Paste the Recording Link into your HubSpot ticket reply and send it to the customer.
  </Step>

  <Step title="Receive the recording">
    When the customer records and submits, you receive an email notification. The Jam appears in your dashboard with a reference to the HubSpot conversation.
  </Step>
</Steps>

***

## What customers experience

The recording flow requires no downloads or account:

1. The customer clicks the Recording Link and it opens directly in their browser.
2. They click **Start Recording** and capture the issue on screen.
3. The recording uploads automatically and you are notified immediately.

***

## What data is collected

Each Jam submitted through a Recording Link includes:

* **Screen recording**: a video of the customer's screen
* **System metadata**: browser version, operating system, screen resolution
* **Reference URL**: the HubSpot conversation URL you attached when creating the link

<Note>Console logs and network requests are not captured by default. To collect them, connect your domain. See [Connect your domain](/docs/custom-recording-domain).</Note>

***

## Tips for HubSpot workflows

<Tip>Create a reusable Recording Link for your support team. Save it as a HubSpot snippet or template so agents can insert it into any reply without generating a new link each time.</Tip>

Use the `jam-reference` URL parameter to automatically attach the ticket URL to every Jam from a reusable link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-reference=https%3A%2F%2Fyourcompany.hubspot.com%2Fagent%2Ftickets%2F125324
```

<Tip>Use the `jam-folder` parameter to route all HubSpot-requested recordings into a dedicated folder in your Jam dashboard, keeping support Jams separate from internal bug reports.</Tip>


# Instant Replay
Source: https://jam.dev/docs/instant-replay

Capture bugs the moment they happen. Instant Replay rewinds the last 2 minutes of activity so you never have to reproduce the issue.

Instant Replay is an opt-in feature. Once enabled, Jam keeps a rolling 2-minute buffer of DOM activity locally so you can share what just happened without reproducing the bug.

## Enable Instant Replay

1. Open the Jam extension.
2. Go to **Settings → Instant Replay**.
3. Toggle **Enable Instant Replay**.

Your preference follows your Jam account, so Instant Replay stays on across browsers and profiles.

## Key benefits

* **Complete technical context:** Every Instant Replay automatically includes DOM session replay, console logs, network requests, and device information.
* **Zero workflow disruption:** You don't need to set up a recording or reproduce the bug. Just capture and share.
* **Engineer-ready format:** All diagnostics are bundled into one link you can drop into a ticket or send directly to an engineer.
* **Privacy controls:** Crop the video portion before sharing to remove any content you don't want included.

## How to trigger Instant Replay

<Steps>
  <Step title="Encounter the bug">
    Continue using the page. Jam tracks DOM changes automatically in the background.
  </Step>

  <Step title="Trigger Instant Replay">
    Click the Jam extension icon and select **Instant Replay**, or use the keyboard shortcut **Shift + Cmd + X**.
  </Step>

  <Step title="Review and crop (optional)">
    In the draft window, preview the captured session. Crop the video portion to remove any sections you don't want to share.
  </Step>

  <Step title="Create and share">
    Click **Create** to upload and generate your shareable link. Jam copies it to your clipboard.
  </Step>
</Steps>

## What Instant Replay captures

Every Instant Replay includes:

* Up to **2 minutes** of DOM session replay
* Console logs (errors and warnings)
* Network requests with full inspection
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size and network speed

<Note>
  Instant Replay is a DOM session replay, not a video recording of your screen. Jam periodically snapshots HTML changes and stitches them together to render a replay inside an iframe. No screen video is ever recorded or stored locally.
</Note>

## Capture limits

| Scenario            | Capture duration           |
| ------------------- | -------------------------- |
| Standard browsing   | Up to 2 minutes            |
| Newly opened tabs   | May be less than 2 minutes |
| Data-heavy websites | May be less than 2 minutes |

Capture duration is limited by available local storage. On pages that generate large volumes of DOM changes rapidly, the buffer fills faster and the lookback window shortens.

## Performance

On heavy websites, Instant Replay can use significant browser memory and affect performance. Jam has safeguards in place so the feature stays lightweight.

Jam automatically disables Instant Replay on heavy websites (many animations, frequent data re-renders, like crypto tickers or spreadsheet apps) to protect performance.

You can override this in the Jam extension settings if your device handles the load well. To revert, remove the website from the override list in extension settings.

## Privacy

Instant Replay is built to be privacy-first:

* All DOM snapshots are stored **locally in your browser**, never sent anywhere.
* The local buffer is **permanently deleted every 120 seconds**.
* Nothing leaves your computer until you explicitly click **Create**.
* Only the content you choose to share is uploaded.

### Disable Instant Replay

You can turn Instant Replay off anytime from **Settings → Instant Replay**. You can also keep it on globally but block it for specific websites.

<AccordionGroup>
  <Accordion title="How far back can Instant Replay capture?">
    Up to 2 minutes of session activity. This may be shorter on newly opened tabs or websites with heavy data loads, as the local buffer fills more quickly on those pages.
  </Accordion>

  <Accordion title="Can I control what gets shared in my Instant Replay?">
    Yes. You can crop the video portion of your Instant Replay before sharing to remove any content you don't want included.
  </Accordion>

  <Accordion title="What technical information is automatically included?">
    Every Instant Replay includes DOM session replay, console logs, network requests, URL, timestamp, country, device information, browser details, and viewport size.
  </Accordion>

  <Accordion title="Is Instant Replay recording my screen in the background?">
    No. Instant Replay snapshots HTML changes in the DOM. It does not record a video of your screen. Nothing is uploaded until you explicitly click Create.
  </Accordion>
</AccordionGroup>


# Integrations overview
Source: https://jam.dev/docs/integrations-overview

Connect Jam to issue trackers, support tools, AI agents, webhooks, and error trackers so every report reaches the right workflow.

Jam integrations send each bug report to the tools where your team already works. Every shared Jam keeps the recording, screenshot, console logs, network requests, and device details attached.

Open [**Settings → Integrations**](https://jam.dev/s/settings/integrations) to connect your tools and route each Jam to the right place.

<Tabs>
  <Tab title="AI & Webhooks">
    <Columns>
      <Card title="ChatGPT" href="/jam-mcp" alt="ChatGPT logo">
        Summarize, analyze, and suggest fixes from your Jams
      </Card>

      <Card title="Claude" href="/jam-mcp" alt="Claude logo">
        Analyze Jams and generate detailed implementation plans
      </Card>

      <Card title="MCP" href="/jam-mcp" alt="MCP logo">
        Connect Jam to Claude, Codex, and other AI tools via MCP
      </Card>

      <Card title="Webhooks" href="/webhooks" alt="Webhooks icon">
        Trigger workflows every time a Jam is created
      </Card>
    </Columns>
  </Tab>

  <Tab title="Project management">
    <Columns>
      <Card title="Linear" href="/linear" alt="Linear logo">
        Create issues with full debug context
      </Card>

      <Card title="Jira" href="/jira" alt="Jira logo">
        Create structured tickets with logs and repro steps
      </Card>

      <Card title="Slack" href="/slack" alt="Slack logo">
        Share and triage issues with your team
      </Card>

      <Card title="GitHub" href="/github" alt="GitHub logo">
        Open issues linked to your codebase
      </Card>

      <Card title="Notion" href="/notion" alt="Notion logo">
        Embed and document bugs or feedback
      </Card>

      <Card title="Azure DevOps" href="/azure-devops" alt="Azure DevOps logo">
        Log bugs with session-level context
      </Card>

      <Card title="Asana" href="/asana" alt="Asana logo">
        Track bugs and requests as tasks
      </Card>

      <Card title="ClickUp" href="/clickup" alt="ClickUp logo">
        Turn recordings into actionable tasks
      </Card>

      <Card title="GitLab" href="/gitlab" alt="GitLab logo">
        Create issues alongside your repos and pipelines
      </Card>
    </Columns>
  </Tab>

  <Tab title="Customer support">
    <Columns>
      <Card title="Freshdesk" href="/freshdesk" alt="Freshdesk logo">
        Turn support conversations into reproducible bug reports
      </Card>

      <Card title="HubSpot" href="/hubspot" alt="HubSpot logo">
        Track customer-reported bugs inside your CRM
      </Card>

      <Card title="Intercom" href="/fin-intercom-setup" alt="Intercom logo">
        Capture and escalate customer issues
      </Card>

      <Card title="Intercom Fin AI" href="/fin-ai-setup" alt="Intercom Fin AI logo">
        Let Fin capture bugs with full Jam context automatically
      </Card>

      <Card title="Jira Service Desk" href="/jira-service-desk" alt="Jira Service Desk logo">
        Request recordings from service desk tickets
      </Card>

      <Card title="ServiceNow" href="/servicenow" alt="ServiceNow logo">
        Link recordings to incidents and service requests
      </Card>

      <Card title="Zendesk" href="/zendesk" alt="Zendesk logo">
        Attach Jams to support tickets for faster resolution
      </Card>
    </Columns>
  </Tab>

  <Tab title="Error tracking">
    <Columns>
      <Card title="FullStory" href="/session-replay-tools" alt="FullStory logo">
        Pair session replays with full debug data
      </Card>

      <Card title="LogRocket" href="/session-replay-tools" alt="LogRocket logo">
        Combine session recordings with developer-grade logs
      </Card>

      <Card title="Sentry" href="/sentry" alt="Sentry logo">
        Attach visual context to errors
      </Card>
    </Columns>
  </Tab>
</Tabs>

<Steps>
  <Step title="Open Settings">
    Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations).
  </Step>

  <Step title="Connect your tools">
    Authenticate with the tools your team uses. Available integrations include:

    * **AI & Webhooks:** ChatGPT, Claude, MCP, Webhooks
    * **Project management:** Linear, Jira, Slack, GitHub, Notion, Azure DevOps, Asana, ClickUp, GitLab
    * **Customer support:** Freshdesk, HubSpot, Intercom, Intercom Fin AI, Jira Service Desk, ServiceNow, Zendesk
    * **Error tracking:** FullStory, LogRocket, Sentry
  </Step>

  <Step title="Send Jams to your tools">
    <Tabs>
      <Tab title="New Jams">
        When creating a new Jam, select your destination from the **link to share** menu before clicking **Create**. Jam posts the capture to the selected tool with all technical context attached.
      </Tab>

      <Tab title="Send existing Jams">
        For existing Jams, open the Jam and click **Send to app** to push it to any connected integration.
      </Tab>
    </Tabs>
  </Step>
</Steps>


# Getting started
Source: https://jam.dev/docs/introduction

Capture bugs with the context engineers need. Start with the Chrome extension, Recording Links, and core debugging tools.

<img alt="Get screen recordings with logs from anyone, above the Jam extension popup with Create link" />

Jam helps support, product, and engineering teams capture bugs with console logs, network requests, and device info attached. More than 250,000 users already capture bugs this way.

## Two ways to create Jams

<CardGroup>
  <Card title="Record a Jam yourself" href="/creating-a-jam" alt="Jam extension popup with Capture Screenshot, Record Tab, and Instant Replay options">
    Capture issues while working with the Chrome extension or iOS app
  </Card>

  <Card title="Request a Jam from anyone" href="/recording-links" alt="Recording Link share URL marked Copied, with the resulting video and synced console logs">
    Collect recordings from customers, teammates, or external collaborators
  </Card>
</CardGroup>

| **Use case**                  | **Best for**                                                               | **When to use**                                                                                  |
| ----------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Request a Jam from anyone** | Collecting recordings from customers, teammates, or external collaborators | Customer bug reports, async user feedback, or remote debugging with your team.                   |
| **Record a Jam yourself**     | Capturing issues while working                                             | Testing your own product, documenting bugs during development, or capturing issues in real time. |

## What gets captured automatically

Every Jam automatically captures essential debugging information.

<CardGroup>
  <Card title="Visual context" alt="Jam video player with click, warning, and diff markers on the timeline">
    Screenshots and screen recordings with annotation tools
  </Card>

  <Card title="Custom logs" alt="Metadata panel showing Location, OS, Battery, Browser, URL, and window dimensions captured with a Jam">
    URL, timestamp, device info, browser version, and operating system
  </Card>

  <Card title="Developer logs" alt="Console log stream showing network errors, a CORS block, an infinite-loop warning, and a SameSite cookie warning">
    Console logs, network requests, errors, and warnings
  </Card>

  <Card title="User events" alt="User events timeline showing clicks, page navigations, and typed input leading up to a bug">
    Clicks, navigation events, and typed input
  </Card>
</CardGroup>

## Customization options

Jam's default capture covers the essentials. You can extend it with custom logs and integrations.

### Jam SDK

* [**Custom logs**](/docs/custom-logs). Push additional context from your app into Jam with a single function call.
* [**Recording links with console logs**](/docs/recording-links). Configure Recording Links to capture console and network logs from customers, with no install required on their end.

### Integrations

Jam connects to the tools your team already uses: send Jams to your issue tracker, request recordings from customers through your support desk, and pull in error tracking and session replay context. See the [integrations overview](/docs/integrations-overview) for the full catalog.

## Next steps

<CardGroup>
  <Card title="Create your first Jam" icon="video" href="/creating-a-jam">
    Capture an issue yourself
  </Card>

  <Card title="Create a Recording Link" icon="link-horizontal" href="/recording-links">
    Collect issues from customers or teammates
  </Card>

  <Card title="Connect your apps" icon="puzzle-piece" href="/integrations-overview">
    Send Jams to Jira, Linear, Slack, GitHub, and other tools.
  </Card>

  <Card title="Debug with MCP" icon="bot" href="/jam-mcp">
    Give AI agents the recording, logs, network requests, and user events from a Jam.
  </Card>
</CardGroup>


# Jam for iOS
Source: https://jam.dev/docs/ios

Capture dev-ready mobile bug reports from your iPhone or iPad and send them straight to your issue tracker.

Jam for iOS lets you capture bug reports directly from your iPhone or iPad, with screen recording, AI-generated titles, and one-tap sharing to your issue tracker.

<Info>
  Visit the App Store to [download](https://apps.apple.com/app/id6469037234) Jam for iOS.
</Info>

<iframe title="Jam for iOS walkthrough" />

## What you can do with Jam for iOS

* **Record your screen** to capture and share mobile bugs.
* **Trim, annotate, and comment** to clarify the issue before sharing.
* **Create a shareable link** or send directly to your issue tracker.
* **AI title and summary.** Narrate your recording and Jam transcribes the audio to generate a title and description automatically.
* **Auto-captions:** Jam generates captions from your voiceover, making recordings easier to follow without audio.
* **Watch existing Jams** from your workspace.

<Note>
  **Supported languages for AI transcription:** English, French, German, Italian, Portuguese, Spanish, Japanese, Korean, Chinese (Simplified and Traditional). If your region isn't listed, Jam uses the nearest equivalent with an already-installed model.
</Note>

## How to record a Jam on iOS

<Steps>
  <Step title="Open Jam and start a broadcast">
    Open the Jam app and tap the strawberry button. Then tap **Start Broadcast** to begin screen recording.
  </Step>

  <Step title="Navigate to the issue">
    Switch to the app or website where the bug occurs. Narrate what you're seeing and doing if you want AI-generated captions and a summary.
  </Step>

  <Step title="Stop the recording">
    When you're done, tap the red status bar or screen recording indicator at the top of your screen and confirm **Stop**, or navigate back to Jam and tap the stop button there.
  </Step>

  <Step title="Trim and describe">
    Trim the video to the relevant section, add a description if needed, then tap **Create Link**.
  </Step>

  <Step title="Share your Jam">
    Wait a few seconds for your Jam to process. Once processing is complete, the link is automatically copied to your clipboard. Make sure the Jam app is open and active on screen when this happens.
  </Step>
</Steps>

## More iOS guides

<CardGroup>
  <Card title="iOS shortcuts for Jam" icon="bolt" href="/ios-shortcuts">
    Start recordings from Control Center, Siri, widgets, or the Action Button.
  </Card>

  <Card title="Setting up logging in iOS" icon="list" href="/ios-logging">
    Send your iOS app's log events to Jam alongside your screen recording.
  </Card>

  <Card title="Enabling taps and gestures" icon="hand-pointer" href="/ios-taps-gestures">
    Show tap indicators and gesture trails in your iOS screen recordings.
  </Card>
</CardGroup>


# Setting up logging in iOS
Source: https://jam.dev/docs/ios-logging

Send your iOS app's log events to Jam with the JamLog framework so every bug report carries your app's context.

The JamLog framework lets you send log events to Jam for iOS so that they can be associated with your Jam.

### Supported Platforms

* iOS 15.0+

### Quick Start

Add the following to your `Package.swift`:

```swift theme={"theme":"css-variables"}
dependencies: [
  .package(url: "https://github.com/jamdotdev/jam-ios-log.git", from: "1.0.0")
]
```

Alternatively, you can add the package directly via Xcode.

### Usage

```swift theme={"theme":"css-variables"}
import Jam

Jam.debug("Hello world!")
```

Also supports `info`, `warn`, and `error`.

### SwiftLog

You can integrate with SwiftLog by importing JamSwiftLog and bootstrapping the logging system:

```swift theme={"theme":"css-variables"}
import JamSwiftLog
import Logging

LoggingSystem.bootstrap { label in
  JamLogHandler(label: label)
}
```

Alternatively, you can add JamLog to your existing logging system by using the `MultiplexLogHandler`:

```swift theme={"theme":"css-variables"}
import JamSwiftLog
import Logging

LoggingSystem.bootstrap { label in
  MultiplexLogHandler([
    StreamLogHandler.standardOutput(label: label),
    JamLogHandler(label: label)
  ])
}
```

### React Native

JamLog is also available as a [React Native Expo module](https://github.com/jamdotdev/expo-jam-log).


# iOS shortcuts for Jam
Source: https://jam.dev/docs/ios-shortcuts

Start a Jam recording from anywhere on your iPhone using Control Center, Siri, widgets, or the Action Button.

### Add Jam Widget to Control Center

**What it does:** Adds a strawberry button to your Control Center that immediately starts a Jam recording.

**Why it's useful:** Control Center is accessible from anywhere on iOS. Perfect for capturing critical moments without switching contexts.

**Setup steps:**

<Steps>
  <Step title="Open Control Center">
    Swipe down from the top-right corner (or up from the bottom on older devices).
  </Step>

  <Step title="Enter edit mode">
    Long-press on any empty space in Control Center.
  </Step>

  <Step title="Add a Control">
    Tap **Add a Control** (plus button).
  </Step>

  <Step title="Add Jam">
    Find Jam and tap the **+** button.
  </Step>

  <Step title="Confirm the shortcut">
    The strawberry icon now appears in your Control Center.
  </Step>
</Steps>

**To use:** Swipe down from the top-right corner (or up from the bottom on older devices), tap the strawberry button, then tap **Start Broadcast** to begin recording.

### Hey Siri, Record a Jam

**What it does:** Voice-activated shortcut that opens Jam's recording screen.

**Why it's useful:** Hands-free activation when you're mid-workflow or demonstrating an issue to someone else.

**Setup steps:**

<Steps>
  <Step title="Trigger Siri">
    Say "Hey Siri, Record a Jam".
  </Step>

  <Step title="Allow permission on first use">
    iOS will ask for permission the first time. Tap **Allow**.
  </Step>

  <Step title="Open the recording screen">
    Jam opens to the recording screen.
  </Step>

  <Step title="Start recording">
    Tap **Start Broadcast** to begin.
  </Step>
</Steps>

**To use:** Say "Hey Siri, Record a Jam" anytime. Works even when your phone is locked.

### Add Jam Widget to Homescreen

**What it does:** Places a widget on your homescreen to start and stop recordings without opening the app.

**Why it's useful:** Essential for dedicated test devices where you're constantly switching between recording and testing. Keeps Jam controls visible and accessible.

**Setup steps:**

<Steps>
  <Step title="Enter edit mode">
    Long-press any empty area on your homescreen.
  </Step>

  <Step title="Open the widget picker">
    Tap the **+** button in the top-left corner.
  </Step>

  <Step title="Find Jam">
    Search for Jam and select it.
  </Step>

  <Step title="Choose a size">
    Pick **Small** or **Medium**.
  </Step>

  <Step title="Add and position the widget">
    Tap **Add Widget**, then move it where it's convenient.
  </Step>
</Steps>

**To use:** Tap the widget, then tap **Start Broadcast** to begin recording.

### Record a Jam with your Action Button

**What it does:** Associate the "Record a Jam" shortcut with your Action Button.

**Why it's useful:** Record a Jam with one button press, from any screen.

**Setup steps:**

<Steps>
  <Step title="Open iOS Settings">
    Go to the **Settings** app on your iPhone.
  </Step>

  <Step title="Find Action Button settings">
    Search for **action button**.
  </Step>

  <Step title="Assign the Record a Jam shortcut">
    Associate the Action Button with the **Record a Jam** shortcut.
  </Step>
</Steps>

**To use:** Press the Action Button, then tap **Start Broadcast** to begin recording.


# Enabling taps and gestures on iOS screen recording
Source: https://jam.dev/docs/ios-taps-gestures

Show taps and gestures in your iOS recordings so engineers can follow exactly what you did.

By following these steps, you can visually represent taps and gestures in your iOS screen recordings using AssistiveTouch.

### Step 1: Enable AssistiveTouch

1. Open the Settings app on your Apple device.
2. Tap Accessibility (found under General in older iOS versions).
3. Under Physical and Motor, tap Touch.
4. On the Touch screen, tap AssistiveTouch.
5. Switch the AssistiveTouch toggle to the on position.

### Step 2: Create a Custom Tap Gesture (Optional)

1. From the AssistiveTouch screen, tap Create New Gesture.
2. Record a tap gesture by tapping the screen once, then tap Save.
3. Name the gesture (e.g., "Tap") and tap Save again.

### Step 3: Use AssistiveTouch During Recording

1. Start your screen recording.
2. Tap the AssistiveTouch shortcut.
3. From the menu, tap Custom.
4. Select the gesture you created (e.g., "Tap").


# AI
Source: https://jam.dev/docs/jam-ai

Generate titles and repro steps automatically so every Jam turns into a ready-to-ship ticket.

<iframe />

## Overview

Jam AI transforms your bug captures into complete, actionable reports. Engineers get the context they need to debug faster, while you spend less time writing tickets.

## Key Benefits

* **Complete bug reports in one click:** no more incomplete tickets
* **Faster debugging:** engineers get structured repro steps and potential fixes
* **Consistent quality:** every ticket includes the details that matter

## How it works

* **AI Auto-Title:** AI generates a short summary of the captured video
* **AI Repro Steps:** AI generates a list of steps to reproduce the captured bug

<Info>
  Jam AI is available only for video Jams.
</Info>

## Managing AI Features

You can control Jam AI at two levels: workspace-wide settings and individual captures.

<Tabs>
  <Tab title="Settings">
    **Workspace-level control**

    1. Control Jam AI for your whole workspace from [**Settings**](https://jam.dev/s/settings).
    2. Go to [**Settings**](https://jam.dev/s/settings)
    3. In general scroll down to the data section
    4. Toggle Jam AI on or off
    5. This setting applies to all members and overrides individual preferences in your workspace.
  </Tab>

  <Tab title="Individual Captures">
    **Per-Capture Control**

    1. Toggle AI features while creating any Jam.
    2. Start creating a new Jam
    3. Look for the AI toggle in the capture interface
    4. Turn it on or off based on your needs
    5. Your choice saves automatically for future captures.
  </Tab>
</Tabs>

## FAQs

<AccordionGroup>
  <Accordion title="Are Jam's AI features free?">
    Free plan: 30 trial uses of Jam AI. Team plan: 200 uses per person per month (14-day free trial available). Enterprise: unlimited. Working on an open-source project? Jam always remains free for open-source projects. [Apply here](https://jam.dev/oss) for Team plan access.
  </Accordion>

  <Accordion title="How is my data used?">
    The data is shared with Google's Gemini AI model for the purpose of providing you with Jam AI functionality. We explicitly opt out of LLMs using Jam customer data for any training. We take steps to de-identify data and protect your privacy. For more details, visit our [AI policies](/docs/ai-policy) page.
  </Accordion>

  <Accordion title="Where can I read Jam's AI policies?">
    Read Jam's AI approach, including data usage and privacy, on the [AI policies](/docs/ai-policy) page.
  </Accordion>
</AccordionGroup>


# MCP
Source: https://jam.dev/docs/jam-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.

<img alt="AI agent debugging a Jam via MCP, with calls to getConsoleLogs, getNetworkErrors, and getUserEvents tools" />

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">
    <Steps>
      <Step title="Open settings">
        From the ChatGPT home page, go to **Settings**.
      </Step>

      <Step title="Navigate to connectors">
        Click **Apps & Connectors**.
      </Step>

      <Step title="Connect Jam">
        Select **Jam** and click the **Connect** button.
      </Step>

      <Step title="Authorize">
        Sign in to Jam and allow access to your workspace.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    <Steps>
      <Step title="Open search and tools">
        From the Claude home page, click **search and tools** on web or desktop.
      </Step>

      <Step title="Add a connector">
        Click **+Add connectors**.
      </Step>

      <Step title="Connect Jam">
        Find **Jam** in the Connector Directory and click the button to connect.
      </Step>

      <Step title="Authorize">
        Sign in to Jam and pick the workspace Claude should access.
      </Step>
    </Steps>
  </Tab>

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

    ```bash theme={"theme":"css-variables"}
    claude mcp add Jam https://mcp.jam.dev/mcp -t http -s user
    ```
  </Tab>

  <Tab title="Codex">
    1. Open or create the config file at `~/.codex/config.toml`
    2. Add the following to your config file and save:

    ```toml theme={"theme":"css-variables"}
    [mcp_servers.jam]
    url = "https://mcp.jam.dev/mcp"
    ```
  </Tab>

  <Tab title="Cursor">
    Add the following to your Cursor MCP configuration:

    ```json theme={"theme":"css-variables"}
    {
      "mcpServers": {
        "jam": {
          "url": "https://mcp.jam.dev/mcp"
        }
      }
    }
    ```

    <Note>
      Restart Cursor after making this change for it to take effect.
    </Note>
  </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

| 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, 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.                                                       |
| `addReaction`               | React to a comment — handy for acknowledging one you've already acted on.                                                                                       |
| `removeReaction`            | Take back a reaction you left on a comment.                                                                                                                     |
| `updateJam`                 | Rename a Jam, rewrite its description, or move it between folders using a folder ID or folder name.                                                             |
| `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.                                                                                                        |
| `archiveJam`                | Archive a Jam. It leaves your lists and search, but the recording is kept, so you can restore it from the dashboard.                                            |
| `deleteComment`             | Delete a comment you wrote, along with its attachments.                                                                                                         |
| `deleteFolder`              | Delete a folder and archive every Jam inside it. Returns how many Jams were archived.                                                                           |
| `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).                                                                                           |

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

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

<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. `getScreenshot` and `analyzeVideo` 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>


# Jira
Source: https://jam.dev/docs/jira

Turn every Jam into a fully loaded Jira issue. Console logs, network requests, and device info are attached automatically.

<iframe />

You can connect Jira and Jam to instantly create Jira tickets right from Jam's browser extension.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every Jira issue

Every Jira issue created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a Jira issue from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Jira as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Jira.
      </Step>

      <Step title="Authenticate with Jira">
        Complete the Jira OAuth flow to connect your account.
      </Step>

      <Step title="Configure your Jira issue">
        Once connected, set up your issue directly from Jam: choose the project, issue type, priority, labels, and more.
      </Step>

      <Step title="Create the issue">
        Click **Create issue**. Jam creates the Jira ticket and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during issue setup to control exactly which Jira fields appear in the Jam extension. Hide fields you never use to keep the workflow fast.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to Jira">
    Create a Jira issue from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a Jira issue.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Jira.
      </Step>

      <Step title="Log in to Jira if prompted">
        If this is your first time using Jam + Jira, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the issue details">
        Enter the project, issue type, priority, labels, and any other fields you need.
      </Step>

      <Step title="Create the issue">
        Click **Create issue** to send the Jam to Jira.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Connect multiple Jira sites">
    Each Jam workspace connects to one Jira site. To work with multiple Jira sites, for example across different clients or companies, create a separate Jam workspace for each one.

    <Steps>
      <Step title="Go to the Jam dashboard">
        Open [jam.dev](https://jam.dev).
      </Step>

      <Step title="Create a new workspace">
        Click **Invite Members** or **Add a Workspace** and follow the prompts.
      </Step>

      <Step title="Connect Jira">
        Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and click **Jira**. The Jira OAuth flow opens in a new tab.
      </Step>

      <Step title="Select the Jira site">
        Choose which Jira site to connect to that workspace.
      </Step>

      <Step title="Repeat for each Jira site">
        Repeat this process for every Jira site you need to connect.
      </Step>
    </Steps>

    ### Swap a connected Jira site

    To switch which Jira site is connected to a Jam workspace:

    <Steps>
      <Step title="Disconnect Jira">
        Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and disconnect Jira.
      </Step>

      <Step title="Revoke Jam access in Atlassian">
        Go to [id.atlassian.com/manage-profile/apps](https://id.atlassian.com/manage-profile/apps), find Jam, and click **Remove access**.
      </Step>

      <Step title="Reconnect to the new Jira site">
        Return to [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and reconnect.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Request a Jam from Jira Service Management Tickets
Source: https://jam.dev/docs/jira-service-desk

Request screen recordings from reporters inside Jira Service Management and link each Jam back to the service request.

Jam works with Jira Service Management through Recording Links, shareable URLs you generate in the Jam browser extension and paste directly into a request or ticket comment. When the reporter clicks the link and records, the resulting Jam arrives in your dashboard with a reference back to the original Jira issue.

## How to request a Jam from Jira Service Management

<Steps>
  <Step title="Create a Recording Link">
    Open the Jam browser extension and click **Request a Recording**.
  </Step>

  <Step title="Paste the issue URL as the link name">
    Copy the Jira issue URL (e.g., `https://yourcompany.atlassian.net/servicedesk/customer/portal/1/ISSUE-123`) and paste it into the Recording Link name field. This creates a reference between the Jam and the issue for easy lookup later.
  </Step>

  <Step title="Generate the link">
    Click **Create link**. The link is automatically copied to your clipboard.
  </Step>

  <Step title="Share the link in the issue">
    Paste the Recording Link into your Jira comment or request reply and send it to the customer or reporter.
  </Step>

  <Step title="Receive the recording">
    When the reporter records and submits, you receive an email notification. The Jam appears in your dashboard with a reference to the Jira issue.
  </Step>
</Steps>

***

## What reporters experience

The recording flow requires no downloads or account:

1. The reporter clicks the Recording Link and it opens directly in their browser.
2. They click **Start Recording** and capture the issue on screen.
3. The recording uploads automatically and you are notified immediately.

***

## What data is collected

Each Jam submitted through a Recording Link includes:

* **Screen recording**: a video of the reporter's screen
* **System metadata**: browser version, operating system, screen resolution
* **Reference URL**: the Jira issue URL you attached when creating the link

<Note>Console logs and network requests are not captured by default. To collect them, connect your domain. See [Connect your domain](/docs/custom-recording-domain).</Note>

***

## Tips for Jira Service Management workflows

Use the `jam-reference` URL parameter to automatically attach the Jira issue URL to every Jam from a reusable link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-reference=https%3A%2F%2Fyourcompany.atlassian.net%2Fbrowse%2FISSUE-123
```

Use the `jam-title` parameter to pre-populate the Jam title with the issue key or summary, making it easier to find recordings in your dashboard:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-title=ISSUE-123+Login+page+crash
```

<Tip>Create a reusable Recording Link and save it as a Jira automation action or comment template. This lets agents request recordings at scale without generating a new link for every issue.</Tip>


# Keyboard shortcuts
Source: https://jam.dev/docs/keyboard-shortcuts

Trigger screenshots, tab recordings, and Instant Replay from your keyboard. Customize any shortcut to fit your workflow.

Control the Jam extension faster with keyboard shortcuts. Skip the clicks and capture bugs, record sessions, or take screenshots directly from your keyboard.

Hover over any button in the Jam extension to see its current shortcut in a tooltip.

## Default shortcuts

<Note>
  Chrome limits browser extensions to 3 default keyboard shortcuts. Jam uses those 3 slots for the most frequently used actions. Desktop Recording does not have a default shortcut, but you can assign one yourself.
</Note>

| Action             | Mac                                         | Windows / Linux                             |
| ------------------ | ------------------------------------------- | ------------------------------------------- |
| Capture screenshot | Shift + Cmd + S                             | Shift + Ctrl + S                            |
| Record tab         | Shift + Cmd + Space                         | Shift + Ctrl + Space                        |
| Instant Replay     | Shift + Cmd + X                             | Shift + Ctrl + X                            |
| Desktop Recording  | No default, customize in extension settings | No default, customize in extension settings |

## Customize shortcuts

You can reassign any shortcut through Chrome's extension settings.

<Steps>
  <Step title="Open extension shortcuts">
    Go to `chrome://extensions/shortcuts` in your address bar.
  </Step>

  <Step title="Find Jam">
    Scroll to find the Jam extension in the list.
  </Step>

  <Step title="Edit a shortcut">
    Click in the shortcut field next to the action you want to change.
  </Step>

  <Step title="Press your new key combination">
    Type the key combination you want to use. The shortcut is saved automatically.
  </Step>
</Steps>

Your updated shortcuts appear in the Jam extension tooltips immediately.

<AccordionGroup>
  <Accordion title="Why doesn't Desktop Recording have a default shortcut?">
    Chrome restricts each extension to 3 default keyboard shortcuts. Jam assigns those defaults to the three most commonly used features: screenshot, tab recording, and Instant Replay. You can add a custom shortcut for Desktop Recording through `chrome://extensions/shortcuts`.
  </Accordion>

  <Accordion title="Can I assign a shortcut to Desktop Recording?">
    Yes. Go to `chrome://extensions/shortcuts`, find Jam, and set a custom key combination for Desktop Recording.
  </Accordion>

  <Accordion title="What happens if my shortcut conflicts with another extension?">
    Your browser warns you about conflicts when you try to save the key combination. Choose a different combination that doesn't conflict with your other extensions.
  </Accordion>
</AccordionGroup>


# Linear
Source: https://jam.dev/docs/linear

Turn every Jam into a Linear issue with full technical context. Set assignees, labels, and priority without leaving the extension.

<iframe />

Connect Jam to Linear to turn every bug capture into a properly formatted Linear issue in one click. All the technical context engineers need is attached automatically, so you never have to fill in debug details by hand.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every Linear issue

Every Linear issue created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a Linear issue from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Linear as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Linear.
      </Step>

      <Step title="Authenticate with Linear">
        Complete the Linear OAuth flow to connect your account.
      </Step>

      <Step title="Configure your Linear issue">
        Once connected, set up your issue from Jam: choose the assignees, labels, priority, project, and more.
      </Step>

      <Step title="Create the issue">
        Click **Create issue**. Jam creates the Linear ticket and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during issue setup to manage which Linear fields are shown in the Jam extension. Remove fields you don't need to speed up your workflow.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to Linear">
    Create a Linear issue from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a Linear issue.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Linear.
      </Step>

      <Step title="Log in to Linear if prompted">
        If this is your first time using Jam + Linear, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the issue details">
        Enter the title, assignee, priority, labels, and any other fields you need.
      </Step>

      <Step title="Create the issue">
        Click **Create issue** to send the Jam to Linear.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Connect multiple Linear workspaces">
    Each Jam workspace connects to one Linear workspace. To work with multiple Linear workspaces, for example across different clients or companies, create a separate Jam workspace for each one.

    <Steps>
      <Step title="Go to the Jam dashboard">
        Open [jam.dev](https://jam.dev).
      </Step>

      <Step title="Create a new workspace">
        Click **Invite Members** or **Add a Workspace** and follow the prompts.
      </Step>

      <Step title="Connect Linear">
        Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and click **Linear**. The Linear OAuth flow opens in a new tab. Log in to the Linear workspace you want to connect.
      </Step>

      <Step title="Confirm the connection">
        After connecting, you'll see which Linear workspace is linked to that Jam workspace. To swap workspaces, disconnect the Linear connection in [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and reconnect to the correct one.
      </Step>

      <Step title="Choose the workspace when capturing">
        When you create Jams, select which Jam workspace (and therefore which Linear workspace) to send each Jam to.
      </Step>

      <Step title="Repeat for each Linear workspace">
        Repeat this process for every Linear workspace you need to connect.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# /jam command on MacOS
Source: https://jam.dev/docs/macos-shortcut

Share a Recording Link from anywhere on your Mac by typing `/jam`. No dashboard, no copy-paste.

This guide shows you how to set up a macOS text replacement so that typing `/jam` in any input field instantly expands into your Jam Recording Link. No switching tabs, no copy-pasting.

<Steps>
  <Step title="Generate a Recording Link">
    Use the Jam extension or dashboard to generate a [Recording Link](https://jam.dev/s/recording-links). Name it "General feedback" or whatever you like, and copy the link.
  </Step>

  <Step title="Open Text Replacements in macOS">
    Go to **System Settings → Keyboard → Text Replacements**.
  </Step>

  <Step title="Add the replacement">
    Click **+**. Enter `/jam` in the **Replace** field and paste the link in the **With** field.

    <Info>
      You can pre-fill the Jam's title by adding `?jam-title=` to the query string. For example: `https://recorder.jam.dev/QrBnf3s?jam-title=Shopping+cart+bug`.
    </Info>
  </Step>

  <Step title="Save the shortcut">
    Click **Add**, then **Done**.
  </Step>

  <Step title="Use /jam anywhere">
    You're all set. Now, in any text input on your Mac, type `/jam` followed by a **Space** or **Return**. macOS will automatically replace it with your Recording Link.

    Anyone who receives the link can click it to record and send you a Jam directly. Here are a few ways to use it:

    * **Slack**: Type `/jam` in a message to a member or in a support channel: *"Seeing something weird? `/jam`. Use this to record what you're experiencing."*
    * **Customer support**: Paste it into a Zendesk, Intercom, or Freshdesk reply: *"Could you record what's happening using this link? `/jam`"*
    * **Email**: Drop it into a support or feedback email to a user.
    * **Linear / Jira / Notion**: Add it to a ticket or doc to ask someone to record a reproduction of a bug.
    * **Onboarding flows**: Send it to new users so they can show you where they're getting stuck.
  </Step>
</Steps>

<Tip>
  You can create multiple text replacements for different contexts. For example, use `/jam-bug` for a bug-report link with a pre-filled title and `/jam-feedback` for a general feedback link.
</Tip>


# Members and roles
Source: https://jam.dev/docs/members-and-roles

Assign Viewer, Creator, and Admin seats so your team gets the right level of access. Your bill reflects only the paid seats you use.

<Info>
  Available to workspaces on our [Team](https://jam.dev/pricing) or [Enterprise](https://jam.dev/pricing) plans.
</Info>

<img alt="Jam role picker with Admin, Creator (selected), and Viewer (Free) seat options" />

## Seat types

<AccordionGroup>
  <Accordion title="Viewer (free)">
    The **Viewer** seat is free and lets people collaborate on Jams. Viewers can access and comment on Jams but cannot create or manage them in workspaces.

    Viewers automatically become **Creator seats** when they take certain actions, such as:

    * Creating a Jam
    * Creating a recording link
    * Sending a Jam to an integration
    * Moving a Jam into a paid workspace via any integration
  </Accordion>

  <Accordion title="Creator (paid)">
    The **Creator** seat is a paid role for people who create and manage content in your workspace. Creators have full capabilities, including:

    * Creating, moving, and deleting Jams and recording links
    * Moving content between workspaces and integrations
    * Actively collaborating within a paid workspace

    Creators impact your workspace’s billing, as each Creator occupies a paid seat.
  </Accordion>

  <Accordion title="Admin (paid)">
    The **Admin** seat is a paid, permanent role for managing settings and members. Admins have all Creator capabilities, plus additional management privileges, including:

    * Managing settings and member roles
    * Controlling billing and subscription details
    * Upgrading or downgrading members between Viewer, Creator, and Admin roles

    Admins also occupy a paid seat and directly impact your billing.
  </Accordion>
</AccordionGroup>

## Examples of seat combinations and billing impact

Since your workspace cost depends on seat types, here are common scenarios:

1. **Only free seats:**
   * **Alex** is invited to view Jams, give feedback, and comment occasionally but does not create new Jams. Alex uses a **Viewer seat**, so your billing stays unaffected.
2. **Free and paid seats:**
   * **Riley** is a product manager who creates Jams regularly as a **Creator**, so billing includes Riley.
   * **Joe** is a developer and uses a **viewer seat** to view and comment on Jams created by Riley. Joe’s viewer seat is a free member of your workspace.
   * **Jordan** frequently manages members and settings. Jordan has an **Admin seat** and is also a paid member.
3. **All paid seats:**
   * **Taylor** actively creates recording links, collaborates on integrations, and manages the workspace. Taylor holds both Creator and Admin capabilities under an **Admin seat**, impacting your billing.

## How people get a paid seat

1. **Self-upgrade (Viewer → Creator)** Viewers can automatically upgrade themselves to a paid Creator seat by performing specific actions:
   * **Create** a new Jam
   * **Create** a new recording link
   * **Move** or copy a Jam into a paid workspace via an integration
   * **Send** content to an integration, triggering active collaboration
   <Note>
     Downgrading a member to a Viewer seat doesn't stop them from self-upgrading again. To turn off automatic upgrades for the whole workspace, switch off **Auto-approve seats** in [**Settings → Billing**](https://jam.dev/s/settings/subscription). Viewers then keep their free seats until an admin upgrades them. Only admins on paid plans can change this setting.
   </Note>
2. **Upgrade via Admin** Admins can manually upgrade a Viewer to a Creator or Admin seat, or  downgrade Creators to Viewers (free) anytime.
   * On Team plan, workspace admins fully manage seat types and billing adjustments.
   * Admins receive notifications each time someone upgrades their seat automatically or manually, helping maintain control of your workspace billing.

<Info>
  **Example:** Casey starts as a **Viewer**. Casey creates a new Jam to collaborate with their team. Creating the Jam upgrades Casey to a **Creator**, and billing updates automatically.
</Info>

## Managing seats

### Team plan

<Steps>
  <Step title="Open Settings → Members">
    Go to [**Settings → Members**](https://jam.dev/s/settings/members).
  </Step>

  <Step title="Change a member's seat type">
    Click their seat type (Viewer, Creator, or Admin) and select a new seat type from the available options.
  </Step>
</Steps>

### Enterprise plan

If your workspace uses Single Sign-On (SSO) and Active Directory sync, you’ll need to manage member roles directly through your Identity Provider (IdP) and Active Directory. You won’t be able to manage these roles directly in Jam.


# Mission
Source: https://jam.dev/docs/mission

Read Jam's mission to make bugs faster to capture, understand, and fix with humans and AI.

Jam exists to make every bug report complete enough for humans and AI agents to fix.

## Speed up software development

Software runs the world. Education, healthcare, finance, AI: every industry moves at the speed of its software teams. The faster those teams ship, the faster everything moves.

Jam exists to fix the slowest part of that loop: turning a bug into a working fix.

## Make every bug fixable by humans and AI

Engineers still get bug tickets without console logs, network requests, or repro steps. They guess at what happened. Now their AI coding agents have to guess too.

Claude Code, Cursor, Copilot, and Codex are only as good as the context you give them. A vague bug ticket produces a vague pull request. A Jam produces a fix.

One click captures the bug with everything engineers and AI agents need to debug it: console logs, network requests, device info, repro steps, and a full session replay. Drop a Jam into your IDE, coding agent, or CI pipeline through the Jam MCP server, and the AI has the full picture before it writes a single line of code.

<Tip>
  **"A bug report is a prompt with context. Jam provides all the context that AI needs to fix the bug."**
</Tip>

This is what bug reporting looks like in the era of agentic software development: structured context that turns AI assistants from autocomplete into actual fixes.

## Inspire beautiful, simple software

Most software is bloated and slow. Bug reporting was a textbook case: install five tools, fill ten fields, paste a screenshot, and type out repro steps. A computer should do that work.

Jam takes those steps away. One click captures everything. The link is shareable, works without an account, and can be easily consumed by Claude Code, Codex, or your favorite AI.

We hold a high bar for what simple, fast, crafted software feels like, and we hope it raises the bar for the rest of the industry.


# Mobile Inspector
Source: https://jam.dev/docs/mobile-inspector

Pair Jam with your browser's mobile inspector to catch responsive layout bugs with device details attached.

You can use Jam to review responsive styles by using Jam alongside your browser's mobile inspector tools.

To preview your website using your browser's mobile inspection:

<Steps>
  <Step title="Open Developer Tools">
    Right click on the website and select "Inspect"
  </Step>

  <Step title="Enable Mobile Inspector">
    In the top left corner of dev tools, click the mobile inspector tool
  </Step>

  <Step title="Record with Jam">
    Then, you can use Jam as usual to log any responsive bugs you see. The updated viewport and device information you have in the mobile inspector will automatically be included in the Jam for your engineers.
  </Step>
</Steps>


# Notion
Source: https://jam.dev/docs/notion

Turn every Jam into a Notion database entry with full technical context. Fill in custom properties from inside the extension.

<iframe />

Connect Jam to Notion to create database entries from your bug captures in seconds. All the technical context your team needs is attached automatically, and you can populate any Notion database property directly from the Jam extension.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every Notion page

Every Notion page created from Jam automatically includes:

* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a Notion page from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Notion as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Notion.
      </Step>

      <Step title="Authenticate with Notion">
        Complete the Notion OAuth flow to connect your account.
      </Step>

      <Step title="Configure your Notion page">
        Once connected, search for the database you want to add the entry to, then populate the custom properties directly from Jam.
      </Step>

      <Step title="Create the page">
        Click **Create page**. Jam creates the Notion page and opens it in a new tab.
      </Step>
    </Steps>

    <Tip>
      Click **Edit fields** during page setup to manage which Notion database properties are shown in the Jam extension. Hide properties you don't need to keep the workflow efficient.
    </Tip>
  </Tab>

  <Tab title="Send an existing Jam to Notion">
    Create a Notion page from any Jam you've already captured in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to convert into a Notion page.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Notion.
      </Step>

      <Step title="Log in to Notion if prompted">
        If this is your first time using Jam + Notion, you'll be redirected to authenticate.
      </Step>

      <Step title="Fill in the database properties">
        Enter the properties for your Notion database entry.
      </Step>

      <Step title="Create the page">
        Click **Create page** to send the Jam to Notion.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Personal access tokens
Source: https://jam.dev/docs/personal-access-tokens

Create personal access tokens to authenticate MCP clients without the OAuth browser flow. Built for headless environments and CI pipelines.

<img alt="Settings MCP token modal with name, expiration, and scope fields" />

Personal access tokens (PATs) let you connect MCP clients to Jam without going through the OAuth browser flow. Instead of authorizing through a browser, you create a token in your Jam settings and paste it directly into your MCP client configuration.

Each token is scoped to a specific workspace, tied to your user account, and has a mandatory expiration date.

<Warning>
  Jam only stores a hash of the token. You cannot retrieve it after creation. Copy your token immediately and store it securely.
</Warning>

## Creating a token

<Steps>
  <Step title="Open Settings → MCP">
    Go to [**Settings → MCP**](https://jam.dev/s/settings/mcp).
  </Step>

  <Step title="Navigate to Personal Access Tokens">
    Scroll to the **Personal Access Tokens** section and click **Create token**.
  </Step>

  <Step title="Fill in the token details">
    Provide the following:

    * **Name**: A label to identify the token, such as "Cursor" or "Claude Code".
    * **Expiration**: How long the token is valid: 7 days, 30 days, 90 days, or 1 year.
    * **Scopes**: The permissions the token needs. See the [Scopes](#scopes) section below.
  </Step>

  <Step title="Create and copy the token">
    Click **Create**, then copy your token immediately. You won't be able to see it again.
  </Step>
</Steps>

## Token format

Jam PATs follow a recognizable format:

```text theme={"theme":"css-variables"}
jam_pat_<random-characters>
```

The `jam_pat_` prefix makes it easy to identify Jam tokens in your configuration and helps secret scanners detect accidental exposure.

## Using a token with MCP clients

Use your PAT as a Bearer token when configuring your MCP client. Replace `jam_pat_...` with your actual token.

<Tabs>
  <Tab title="Claude Code">
    ```bash theme={"theme":"css-variables"}
    claude mcp add Jam https://mcp.jam.dev/mcp \
      -t http \
      -s user \
      --header "Authorization: Bearer jam_pat_..."
    ```
  </Tab>

  <Tab title="Cursor">
    ```json theme={"theme":"css-variables"}
    {
      "mcpServers": {
        "Jam": {
          "url": "https://mcp.jam.dev/mcp",
          "headers": {
            "Authorization": "Bearer jam_pat_..."
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code / Windsurf">
    Add to your `mcp.json`:

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

<Tip>
  PATs skip the OAuth browser authorization step entirely. This makes them ideal for headless environments or CI pipelines.
</Tip>

## Scopes

Scopes control what a token can do. Select only the scopes you need.

| Scope       | Description                                           |
| ----------- | ----------------------------------------------------- |
| `mcp:read`  | View Jam details, logs, events, and network requests. |
| `mcp:write` | Move Jams to folders and add comments.                |

You must select at least one scope when creating a token.

## Managing tokens

### Viewing your tokens

Go to [**Settings → MCP**](https://jam.dev/s/settings/mcp) to see all personal access tokens for the current workspace. The list shows each token's name, scopes, last used date, and expiration status.

### Revoking a token

<Steps>
  <Step title="Find the token">
    Go to [**Settings → MCP**](https://jam.dev/s/settings/mcp) and locate the token you want to revoke.
  </Step>

  <Step title="Open the token menu">
    Click the **...** menu on the right side of the token row.
  </Step>

  <Step title="Revoke the token">
    Select **Revoke token** and confirm the revocation.
  </Step>
</Steps>

<Warning>
  Revoking a token is permanent. Any MCP client using the token will immediately lose access.
</Warning>

## Expiration

All tokens have a mandatory expiration date. Choose the expiration period that matches your use case:

| Duration | Recommended for                |
| -------- | ------------------------------ |
| 7 days   | Short-lived tasks or testing   |
| 30 days  | Active development work        |
| 90 days  | Longer-running integrations    |
| 1 year   | Stable, long-term integrations |

Expired tokens stop working automatically. When a token expires, create a new one and update your MCP client configuration.

## Security best practices

* **Use short-lived tokens**: Choose the shortest expiration that works for your use case.
* **Limit scopes**: Grant the permissions the token needs.
* **Never commit tokens**: Store tokens in environment variables or your MCP client's secure credential storage, not in files checked into version control.
* **One token per client**: Create separate tokens for each MCP client so you can revoke them independently.
* **Revoke immediately if compromised**: If a token may have been exposed, revoke it right away and create a replacement.


# Pricing
Source: https://jam.dev/docs/pricing

Compare Jam plans and choose the right plan for your workspace.



# Recording Links
Source: https://jam.dev/docs/recording-links

Share one URL to collect screen recordings and technical context from anyone. No install, no account, no downloads on their end.

<iframe />

Recording Links are shareable URLs that let anyone record their screen and send you a Jam. No browser extension, no account, no downloads required. Generate a link from your dashboard or browser extension, paste it wherever your customers already are, and receive a full recording with technical context the moment they submit.

## How it works

<Steps>
  <Step title="Generate a recording link">
    Create a link from your [Jam dashboard](https://jam.dev/s/recording-links) or from the browser extension.
  </Step>

  <Step title="Share the link">
    Paste it into an email, support ticket, chat message, or customer form.
  </Step>

  <Step title="Recipient clicks and records">
    The link opens directly in their browser. They click **Start Recording** and capture the issue.
  </Step>

  <Step title="Recording appears in your dashboard">
    You receive an email notification and the Jam appears in your dashboard with full technical context.
  </Step>
</Steps>

<Note>
  Recording Links work on any device. Recipients do not need a Jam account or the browser extension. Compatible with the desktop versions of Chrome, Edge, Firefox, and Safari.
</Note>

***

## When to use Recording Links

* **Customer support.** Replace vague descriptions with visual reproductions.
* **External bug reports.** Get technical context from users outside your team.
* **QA workflows.** Capture specific scenarios and environments.
* **Remote debugging.** See issues that occur only in specific setups.

***

## Create a link

<Tabs>
  <Tab title="From the browser extension">
    <Steps>
      <Step title="Open the extension">
        Click the Jam strawberry icon to open the extension.
      </Step>

      <Step title="Click Create Recording Link" />

      <Step title="Name your link (optional)">
        Give it a name, or paste the URL of the customer conversation (from Zendesk, HubSpot, Jira, etc.) as the link name for later reference.
      </Step>

      <Step title="Choose workspace or domain (optional)">
        If you have multiple workspaces or custom domains, select the one you want to use. You can also choose a folder to route Jams created from this link into it.
      </Step>

      <Step title="Create the link">
        Click **Create link**. The link is automatically copied to your clipboard.
      </Step>
    </Steps>
  </Tab>

  <Tab title="From the dashboard">
    <Steps>
      <Step title="Go to Recording Links">
        Navigate to [jam.dev/s/recording-links](https://jam.dev/s/recording-links).
      </Step>

      <Step title="Create a new link">
        Click **New Recording Link**. A pop-up appears.
      </Step>

      <Step title="Name your link (optional)">
        Optionally name the link or paste the URL of the customer conversation for reference.
      </Step>

      <Step title="Create the link">
        Click **Create Link**. The link is automatically copied to your clipboard, ready for sharing.
      </Step>
    </Steps>
  </Tab>
</Tabs>

***

## Share a link

Recording Links work anywhere you can paste a URL:

* **Email**: "Hi there, can you click this link and show us what you're experiencing? \[recording link]"
* **Support tickets**: paste directly into Zendesk, Intercom, or HubSpot responses
* **Chat messages**: Slack, Teams, or any messaging platform
* **Customer forms**: include in help documentation or contact forms

<Tip>
  When you create a link, paste the URL of the customer conversation as the link name. That way, you always have the context when a new recording comes in.
</Tip>

### What recipients experience

The recording flow is designed for non-technical users:

1. **Instant access**: the link opens directly in their browser, no downloads
2. **Simple interface**: a large **Start Recording** button with clear instructions
3. **One-click recording**: captures their screen, showing the bug
4. **Submit recording**: recording uploads automatically and notifies you immediately

***

## View submissions

Jams submitted through a Recording Link appear in your Jam dashboard as regular Jams:

1. You receive an email notification when a Jam from your Recording Link is recorded.
2. Find the recording in [your workspace's Jam dashboard](https://jam.dev/s) and in the [Recording Links page](https://jam.dev/s/recording-links), where you can see all Jams grouped by link.

***

## Reusable links

Recording Links are reusable by default. A single link can receive unlimited submissions, making them ideal for:

* Ongoing customer support or QA workflows
* Feedback buttons embedded in your product
* Email signatures
* Pinned Slack messages

## URL parameters

Customize the behavior of any Recording Link by appending query parameters to the URL.

#### Set the Jam title

Use `jam-title` to pre-populate the title of every Jam created from this link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-title=Shopping+cart+bug
```

For a same-domain Recording URL:

```text theme={"theme":"css-variables"}
https://www.yoursite.com/?jam-id=QrBnf3s&jam-title=Shopping+cart+bug
```

#### Additional parameters

| Parameter                      | Description                                                                                                                                                  |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `jam-title=<TITLE>`            | Sets the title of the recorded Jam                                                                                                                           |
| `jam-folder=<FOLDER_ID>`       | Routes the Jam into a specific folder. Use the 4-character folder ID from the folder's URL in your dashboard: `https://jam.dev/s/<WORKSPACE-ID>/<FOLDER-ID>` |
| `jam-reference=<URL_OR_EMAIL>` | Associates a user identifier or URL (e.g., a helpdesk conversation, issue tracker link)                                                                      |

<Tip>
  URL parameters are useful when building macros, text expanders, or custom link generators for your team. You can encode the ticket URL and title directly into the recording link before sending it.
</Tip>

***

## Adding a reference

Attach a reference to a Recording Link to automatically link the resulting Jam back to the issue you're tracking.

<Steps>
  <Step title="Copy your ticket URL">
    Copy the link to the relevant ticket in your issue tracker (Jira, Linear, GitHub, etc.).

    <Frame>
      <img alt="Jira ticket for a shopping cart bug with the Copy link action highlighted" />
    </Frame>
  </Step>

  <Step title="Add the reference when creating the link">
    In the **Reference name or link** field, paste the ticket URL. Jam identifies your issue tracker and displays the ticket number.

    You can also enter any web URL or email address as a reference.

    <Frame>
      <img alt="New Recording Link dialog with the Jira OLST-7 reference entered and the Reusable toggle on" />
    </Frame>
  </Step>

  <Step title="Send the Recording Link">
    Share the Recording Link with your customer.
  </Step>

  <Step title="Jams link back automatically">
    When the customer submits a recording, Jam links the resulting Jam back to your ticket automatically.
  </Step>
</Steps>

***

## Capture logs from your domain

By default, Recording Links capture only screen recordings.

To also collect console logs, network requests, user interaction events, and enable automatic blurring, you need to connect your domain and install Jam's scripts on your site.

Once configured, logs are automatically attached to each submitted Jam.

<Note>
  See [Connect your domain](/docs/custom-recording-domain) for the full setup guide.
</Note>

***

## Privacy and automatic blurring

When [your domain is connected](/docs/custom-recording-domain), Jam can automatically detect and blur sensitive information during recordings. Blurring happens directly in the browser before the recording is uploaded, so sensitive data never leaves the user's device unprotected.

### What gets blurred automatically

Jam detects and blurs the following by default:

* Password fields
* Credit card numbers (including CVV, expiration, and card number fields)
* Social security numbers and tax IDs
* Bank account and routing numbers
* Passport and driver's license fields
* Phone numbers and email addresses
* API keys and tokens

Jam also recognizes privacy selectors from popular session replay tools. If you already use FullStory, Hotjar, LogRocket, Sentry, Microsoft Clarity, OpenReplay, Highlight.io, ContentSquare, Matomo, Heap, or Amplitude, your existing privacy configuration works automatically with Jam.

### Custom blur rules

If you run Jam on your own domain, control blur behavior with HTML data attributes:

```html theme={"theme":"css-variables"}
<!-- Force blur on an element -->
<div data-jam-blur>
  Sensitive content
</div>

<!-- Prevent blur on an element -->
<div data-jam-no-blur>
  Non-sensitive content
</div>
```

To pass custom CSS selectors using the SDK:

```javascript theme={"theme":"css-variables"}
import * as jam from "@jam.dev/recording-links/sdk";

jam.initialize({ blurSelectors: ".my-custom-blur-class" });
```

Or using a `<meta>` tag:

```html theme={"theme":"css-variables"}
<meta name="jam:blur" content=".my-custom-blur-class" />
```

<Note>
  Manual opt-out (`data-jam-no-blur`) overrides all other blur rules, including custom selectors.
</Note>

### Limitations

* Content inside iframes must be blurred entirely. Selective blurring inside an iframe is not supported.
* Flashes of unblurred content may occur on page load if your UI initializes before Jam.js. Move Jam.js initialization earlier in your page's execution to prevent this.
* When the browser window is resized during a recording, blurred content may briefly become visible as the page reflows.

***

## FAQ

<AccordionGroup>
  <Accordion title="Can anyone use a Recording Link?">
    Yes. Anyone with the link can record. No account or installation is required.
  </Accordion>

  <Accordion title="Do Recording Links expire?">
    No. Recording Links are reusable and do not expire. A single link can receive unlimited submissions.
  </Accordion>

  <Accordion title="Can I restrict who can submit recordings?">
    Recording Links are accessible to anyone with the URL. There is no way to restrict submissions to specific users.
  </Accordion>

  <Accordion title="Do Recording Links capture console logs automatically?">
    No. By default, Recording Links capture screen recordings only. To capture console logs and network requests, you must connect your domain and install Jam's Recorder and Capture scripts.
  </Accordion>

  <Accordion title="Are recordings secure?">
    Yes. Jam automatically blurs sensitive information directly in the browser before the recording is uploaded. Sensitive data never reaches Jam's servers unprotected.
  </Accordion>

  <Accordion title="Can I customize what happens when someone submits a recording?">
    Yes. Use URL parameters to route recordings to specific folders (`jam-folder`), set a custom Jam title (`jam-title`), or associate a reference URL or user identifier (`jam-reference`).
  </Accordion>
</AccordionGroup>


# Screenshot
Source: https://jam.dev/docs/screenshot

Capture full-page or cropped screenshots with console logs, network requests, and device info attached. Engineers get everything they need to fix the bug.

You can use Jam to quickly capture a screenshot of a bug – along with all the technical details engineers need to troubleshoot and fix bugs. Unlike other screenshot tools, Jam's screenshot tool is purpose-built for product, engineering, support, and QA teams.

## What gets captured automatically

When you take a screenshot with Jam, the following technical diagnostics are automatically included:

* Console logs
* Fully inspectable network requests
* URL
* Timestamp and country
* Device, OS, and browser
* Viewport size
* Network speed
* Full-page context of any cropped screenshot

## Take a screenshot

<Steps>
  <Step title="Open the Jam extension">
    Click the Jam icon in your browser toolbar to open the extension.
  </Step>

  <Step title="Select the screenshot tool">
    Choose **Capture screenshot** from the extension panel.
  </Step>

  <Step title="Capture the screen">
    * **Full-screen screenshot:** Click once anywhere on the page to capture the entire viewport.
    * **Cropped screenshot:** Click and drag to select the specific area you want to capture.
  </Step>

  <Step title="Annotate (optional)">
    After the screenshot is captured, use the annotation tools to mark up the image.
  </Step>

  <Step title="Create and share">
    Click **Create** to generate a shareable link. Jam packages the screenshot and all technical diagnostics into one link and copies it to your clipboard.
  </Step>
</Steps>

<Note>
  When you take a cropped screenshot, Jam also captures a full-page screenshot and displays both side-by-side in the Jam report. This helps engineers understand exactly where on the page the cropped area came from. To exclude the full-page screenshot, deselect that option in the draft window before clicking **Create**.
</Note>


# Security
Source: https://jam.dev/docs/security

See how Jam keeps your data safe: SOC 2 Type II compliance, AES-256 encryption, automatic blurring, SSO, and audit logs.

Jam is built to meet enterprise security standards. Your data is encrypted at rest and in transit with AES-256, stored on Google Cloud Platform, and audited annually by third parties. This page covers how Jam handles your data, what compliance certifications are in place, and how to contact the security team.

## Compliance and certifications

| Certification     | Status                                                        |
| ----------------- | ------------------------------------------------------------- |
| **SOC 2 Type II** | Compliant. Annual audits, quarterly vulnerability assessments |
| **GDPR**          | Compliant                                                     |
| **HIPAA**         | Coming soon                                                   |

To request the SOC 2 Type II report, email [security@jam.dev](mailto:security@jam.dev) with your company information and intended use. The security team will verify your qualifications and provide the report.

## Data storage and infrastructure

* **Cloud provider:** Google Cloud Platform, Central US region
* **CDN:** Cloudflare
* **Encryption at rest:** AES-256
* **Encryption in transit:** HTTPS/TLS
* **Backups:** Automated snapshots with the following retention schedule:

| Frequency | Retention |
| --------- | --------- |
| Hourly    | 2 days    |
| Daily     | 7 days    |
| Weekly    | 4 weeks   |
| Monthly   | 12 months |

All cloud services, source code access, and third-party tools are secured with two-factor authentication.

## Data privacy

**Where recordings are stored**

Jam stores all recordings in Google Cloud Platform. Jam does not currently support redirecting recordings to your own storage solution.

**Data retention**

Jams don't expire. A Jam stays available until someone deletes it, or until the account or workspace it belongs to is deleted - nothing is deleted automatically through inactivity.

When you delete a Jam, it isn't hard-deleted immediately, it's archived first.

If a workspace is archived, its data enters a 90-day window, after which an automated clean-up job permanently deletes it and all associated data. Jams created by a member who leaves or deletes their own account stay with the workspace - that content is only permanently deleted when the entire workspace is closed.

Enterprise customers can set a custom data deletion schedule for their workspace. Contact [Jam](https://jam.dev/contact-sales) to configure your preferred schedule.

**Consent**

An end customer must actively choose to start a recording and then submit it before any visual or browser data is stored by Jam. Both steps are explicit consent actions that the user can decline.

## Sensitive data handling

Jam includes two protections to minimize the sensitive information collected during recordings:

* **Automatic blurring**: Jam automatically blurs sensitive content in screen recordings. You can customize which data elements are blurred to match your product context.
* **Network request obfuscation**: Jam obfuscates sensitive data from captured network requests, such as authorization headers and tokens.

## AI policy

Jam AI features are powered by third-party AI models. Here is how Jam handles your data when AI is involved:

* Data is encrypted at rest and in transit
* Third-party AI providers **do not** train their models on your customer data
* Vendors may process data temporarily to enable AI features, but Jam limits how long they retain it
* Jam takes steps to de-identify and anonymize content before processing

Jam AI (ticket creation, reproduction step generation) uses **Google Gemini** and is opted out of model training. The **AI Debugger** feature uses the **OpenAI API**. OpenAI does not train on data sent through the API.

You can manage AI features in [**Settings**](https://jam.dev/s/settings).

## Enterprise security features

<Note>
  The following features are available on the **Enterprise** plan. [Contact sales](https://jam.dev/contact-sales) to upgrade.
</Note>

* **Single Sign-On (SSO)**: connect your identity provider for centralized authentication
* **Audit logs**: track every significant workspace action with a full activity trail
* **Custom data retention**: set deletion schedules to control how long Jams are stored
* **Access controls**: set default visibility for all Jams in your workspace

## Security monitoring

**Vulnerability testing:** Jam performs quarterly vulnerability scans and annual penetration tests as required by SOC 2 Type II compliance. GitHub's dependency vulnerability feed monitors third-party dependencies in Jam's source code continuously.

**Intrusion detection:** Jam uses Cloudflare for attack prevention and GCP firewalls for infrastructure protection. Because the production network is fully managed by GCP, Jam does not run a separate IDS/IPS.

**Incident response:** The security team reviews reports immediately and notifies affected users of confirmed incidents.

## Contact security

For security questions, vulnerability reports, or to request the SOC 2 report, email [security@jam.dev](mailto:security@jam.dev). The team responds as quickly as possible and keeps you updated throughout any investigation.

Jam does not currently offer a bug bounty program.

## Related pages

<CardGroup>
  <Card title="SSO" icon="key" href="/sso">
    Connect your identity provider for enterprise authentication.
  </Card>

  <Card title="Audit logs" icon="list" href="/audit-logs">
    Track workspace activity for compliance and oversight.
  </Card>

  <Card title="Access controls" icon="lock" href="/access-controls">
    Control who can view your Jams.
  </Card>
</CardGroup>


# Sentry
Source: https://jam.dev/docs/sentry

See Sentry backend errors and logs alongside your Jam captures. Trace bugs from the frontend all the way through your stack.

<iframe />

Connect Jam to Sentry to see backend errors and service logs right alongside your frontend captures. When a bug is reported with Jam, you can immediately see the Sentry events from the same timeframe, giving engineers a direct path from the symptom to the root cause across your full infrastructure.

<Info>
  The Sentry integration is available on the Team plan only. See [jam.dev/pricing](https://jam.dev/pricing) for details.
</Info>

## How the integration works

When Sentry is connected, Jam displays Sentry events from the 5 minutes before and after the Jam was created. Logs are filtered by the environment field sent from your frontend to Sentry. For example, if your client app sends events with `environment: staging`, Jam will scope the displayed Sentry logs to `environment:staging` by default.

You can also:

* Filter logs by timestamp range
* Search for specific keywords to find relevant Sentry events
* Click any Sentry event listed in Jam to open it directly in Sentry

If you're on a Sentry business plan, you can view events across all your Sentry projects. On lower Sentry tiers, you can view one project at a time.

## Connect Jam to Sentry

<Steps>
  <Step title="Look for the Sentry tab in Jam">
    When you open a Jam on a website where Sentry is detected, a Sentry tab appears automatically. Click it to begin the authentication flow.
  </Step>

  <Step title="Complete the Sentry OAuth flow">
    Click the connect button and authorize Jam through the Sentry OAuth flow.
  </Step>

  <Step title="View Sentry events in Jam">
    Once connected, Sentry events from the same timeframe as the Jam appear directly inside the Jam view.
  </Step>
</Steps>

<Note>
  If Sentry is not installed on the website you're capturing, you can still connect from the Jam dashboard. Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations) and connect Sentry from there.
</Note>


# Request a Jam from ServiceNow Incidents and Requests
Source: https://jam.dev/docs/servicenow

Request screen recordings from users inside ServiceNow and link each Jam back to the incident or service request.

Jam works with ServiceNow through Recording Links, shareable URLs you generate in the Jam browser extension and paste directly into an incident or service request. When the user clicks the link and records, the resulting Jam arrives in your dashboard with a reference back to the original ServiceNow record.

## How to request a Jam from ServiceNow

<Steps>
  <Step title="Create a Recording Link">
    Open the Jam browser extension and click **Request a Recording**.
  </Step>

  <Step title="Paste the incident URL as the link name">
    Copy the ServiceNow incident or request URL (e.g., `https://yourcompany.service-now.com/now/nav/ui/classic/params/target/incident.do%3Fsys_id%3DABC123`) and paste it into the Recording Link name field. This creates a reference between the Jam and the incident for easy lookup later.
  </Step>

  <Step title="Generate the link">
    Click **Create link**. The link is automatically copied to your clipboard.
  </Step>

  <Step title="Share the link in the incident">
    Paste the Recording Link into the ServiceNow incident work note or customer reply and send it to the user.
  </Step>

  <Step title="Receive the recording">
    When the user records and submits, you receive an email notification. The Jam appears in your dashboard with a reference to the ServiceNow incident.
  </Step>
</Steps>

***

## What users experience

The recording flow requires no downloads or account:

1. The user clicks the Recording Link and it opens directly in their browser.
2. They click **Start Recording** and capture the issue on screen.
3. The recording uploads automatically and you are notified immediately.

***

## What data is collected

Each Jam submitted through a Recording Link includes:

* **Screen recording**: a video of the user's screen
* **System metadata**: browser version, operating system, screen resolution
* **Reference URL**: the ServiceNow incident URL you attached when creating the link

<Note>Console logs and network requests are not captured by default. To collect them, connect your domain. See [Connect your domain](/docs/custom-recording-domain).</Note>

***

## Tips for ServiceNow workflows

Use the `jam-reference` URL parameter to automatically attach the incident URL or incident number to every Jam from a reusable link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-reference=INC0012345
```

Use the `jam-title` parameter to pre-populate the Jam title with the incident number or short description:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-title=INC0012345+VPN+connection+failure
```

<Tip>Create a reusable Recording Link and add it to a ServiceNow email notification template or catalog item description. This lets your service desk team request recordings at scale without generating a new link per incident.</Tip>


# Session replay tools
Source: https://jam.dev/docs/session-replay-tools

Link FullStory and LogRocket sessions to your Jams automatically. Engineers get both the capture and the full user session.

If your website uses **FullStory** or **LogRocket** for customer behavior and analytics, your Jams automatically include a link to the session recording. You'll find the link in the info panel in Jam logs.

You don't have to connect anything to get started or write code. The session link appears for your devs every time you report a bug with Jam.


# Slack
Source: https://jam.dev/docs/slack

Send Jams to any Slack channel with rich previews and inline debug timelines. Engineers start debugging without leaving the chat.

<iframe />

Connect Jam to Slack to send bug reports directly to any channel, DM, or private group. Every message includes the full debug context, and Jam links shared in Slack automatically expand into rich previews showing error timelines, so engineers can start debugging without opening a new tab.

<Info>You need the Jam Chrome extension installed. See [Getting Started](/docs/introduction) if you haven't set it up.</Info>

## What's included in every Slack message

Every Slack message sent from Jam automatically includes:

* Screen capture (screenshot, video, or instant session replay)
* Console logs
* Fully inspectable network requests
* URL, timestamp, and country
* Device, OS, and browser
* Viewport size
* Network speed

<Tabs>
  <Tab title="Create a Slack message from a new capture">
    <Steps>
      <Step title="Capture your bug">
        Use the Jam browser extension to capture your bug.
      </Step>

      <Step title="Select Slack as the destination">
        In the Jam extension, click **Link you can share** and change the destination to Slack.
      </Step>

      <Step title="Authenticate with Slack">
        Complete the Slack OAuth flow to connect your account.
      </Step>

      <Step title="Choose a channel">
        Once connected, choose which channel, private group, or specific user to send the Jam to. You can only access conversations you're already a member of.
      </Step>

      <Step title="Send the message">
        Click **Send message**. The Jam opens in a new tab and your message is posted to the selected Slack channel.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Send an existing Jam to Slack">
    Post any existing Jam to Slack in two clicks.

    <Note>
      You must be logged into Jam to use this feature. Logged-out users will not see the **Send to App** option.
    </Note>

    <Steps>
      <Step title="Open the Jam">
        Open the Jam you want to share in Slack.
      </Step>

      <Step title="Click Send to App">
        Click **Send to App** and select Slack.
      </Step>

      <Step title="Log in to Slack if prompted">
        If this is your first time using Jam + Slack, you'll be redirected to authenticate.
      </Step>

      <Step title="Choose a channel">
        Choose which channel, private group, or specific user to send the Jam to.
      </Step>

      <Step title="Send the message">
        Click **Send message** to post the Jam to Slack.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Enable inline Jam previews in Slack

Once you connect your Jam account to Slack, any Jam link you paste into Slack will automatically expand into a rich preview. Engineers see debug context directly in Slack (including error timelines on videos and replays) without opening a separate tab.

<Steps>
  <Step title="Open the Jam dashboard">
    Go to [jam.dev](https://jam.dev).
  </Step>

  <Step title="Open Settings → Integrations">
    Go to [**Settings → Integrations**](https://jam.dev/s/settings/integrations).
  </Step>

  <Step title="Connect Slack">
    Click **Slack** and complete the OAuth flow to connect your account.
  </Step>
</Steps>

After connecting, every Jam link you share in Slack will show an expanded preview formatted for engineers.


# SSO
Source: https://jam.dev/docs/sso

Connect your identity provider for single sign-on and automatic workspace management. Access stays centralized and manual work stays low.

<Info>
  SSO and Directory Sync are available on the [**Enterprise**](https://jam.dev/pricing) plan only. [Contact sales](https://jam.dev/contact-sales) to upgrade.
</Info>

<img alt="Single Sign-On settings showing GoogleSAML for @acme.com and Google Workspace with 21 synced members" />

## How it works

**SSO (Single Sign-On)** connects your identity provider to Jam for authentication. Team members log in using their existing corporate credentials instead of a separate Jam password.

**Directory Sync** automatically reflects user changes from your IdP in Jam. Changes to your IdP sync automatically to your Jam workspace with no manual work.

## Supported identity providers

* Okta
* Azure AD
* Google Workspace
* Any SAML-compatible provider

## Configure

<Tabs>
  <Tab title="SSO setup">
    Configure Single Sign-On

    <Steps>
      <Step title="Open Settings">
        Go to [**Settings**](https://jam.dev/s/settings).
      </Step>

      <Step title="Start the SSO setup">
        In the **Access** section, click **Setup** next to **Identity Provider**.
      </Step>

      <Step title="Follow the guided walkthrough">
        Follow the setup walkthrough for your identity provider.
      </Step>

      <Step title="Finish configuration in your IdP">
        Complete the required configuration steps on your identity provider's side.
      </Step>
    </Steps>

    You should now see your IdP listed in the Access section. Members can now log in with SSO.

    <Info>
      SSO is configured for a single domain by default. Need multiple domains? [Contact](https://jam.dev/help) our team to enable additional domains.
    </Info>
  </Tab>

  <Tab title="Directory Sync setup">
    Configure Directory Sync to automate user provisioning and removal.

    <Steps>
      <Step title="Open Settings">
        Go to [**Settings**](https://jam.dev/s/settings).
      </Step>

      <Step title="Start the Directory Sync setup">
        In the **Access** section, click **Setup** next to **Active Directory**.
      </Step>

      <Step title="Follow the guided walkthrough">
        Complete the step-by-step configuration walkthrough for your IdP.
      </Step>

      <Step title="Select user groups to sync (optional)">
        Choose which user groups from your IdP should sync to Jam. This step is optional.
      </Step>
    </Steps>

    You should now see your IdP listed in the Access section. New users added to your IdP automatically join your workspace.

    <Info>
      Provisioned users get the Creator role by default. You'll need to adjust roles manually in [**Settings → Members**](https://jam.dev/s/settings/members).
    </Info>
  </Tab>
</Tabs>

## User management

How you manage team members depends on whether Directory Sync is enabled.

<Tabs>
  <Tab title="With Directory Sync">
    <img alt="Members list with the Active Directory sync enabled banner and 21 synced members" />

    **Automated Management**

    * User provisioning: Happens in your identity provider
    * New user notifications: Users get email notifications when provisioned
    * Role management: Handle manually in [**Settings → Members**](https://jam.dev/s/settings/members)
    * User removal: Remove from IdP to revoke Jam access automatically
    * Group sync: Manage access via user groups in your IdP

    Access Directory Sync management in [**Settings → Members**](https://jam.dev/s/settings/members).

    <Info>
      User groups cannot be mapped to specific Jam roles automatically. Role assignment requires manual configuration.
    </Info>
  </Tab>

  <Tab title="Without Directory Sync">
    <img alt="Members list with the Add members button and three members, with no Directory Sync banner" />

    **Manual Management**

    * User provisioning: Add users directly in [**Settings → Members**](https://jam.dev/s/settings/members)
    * Role management: Assign and modify roles in Jam
    * User removal: Remove users manually in [**Settings → Members**](https://jam.dev/s/settings/members)

    All user management happens in [**Settings → Members**](https://jam.dev/s/settings/members).

    <Warning>
      User groups cannot be mapped to specific Jam roles automatically. Role assignment requires manual configuration.
    </Warning>
  </Tab>
</Tabs>

## FAQ

<AccordionGroup>
  <Accordion title="Can I use SSO without Directory Sync?">
    Yes. SSO handles authentication while Directory Sync manages user provisioning. You can enable either feature independently.
  </Accordion>

  <Accordion title="What identity providers are supported?">
    Jam supports all major identity providers, including Okta, Azure AD, Google Workspace, and any SAML-compatible provider.
  </Accordion>

  <Accordion title="Can I map user groups to specific Jam roles?">
    Not automatically. While you can sync user groups from your IdP, role assignment requires manual configuration in [**Settings → Members**](https://jam.dev/s/settings/members).
  </Accordion>

  <Accordion title="What happens when I remove a user from my identity provider?">
    With Directory Sync enabled, the user automatically loses access to Jam when they are removed from your IdP.
  </Accordion>
</AccordionGroup>


# Contact support
Source: https://jam.dev/docs/support

Get help with Jam setup, captures, integrations, and account questions.



# Values
Source: https://jam.dev/docs/values

Read the values that guide how Jam builds with customers, ships, and keeps software simple.

Jam values guide how we choose what to build, how we listen to customers, and how we hold the product bar.

## Build in partnership with our customers

Jam is a true collaboration with our customers. We exist to serve you, not the other way around. This means proactively seeking feedback, acting on it quickly, and being transparent about what we're building and why.

* Every new power user hears from a Jam PM or engineer asking for feedback.
* All user feedback is shared in a dedicated Slack channel for internal discussion and action.
* We try to spend as much time as we can talking to users.
* We listen to clips from recent user interviews together as a company and discuss.

## Simplicity first, simplicity always

We're here to simplify bug reporting and take away manual steps. Simplicity isn't a feature. It's a first principle in everything we build. If something feels complicated, we ask whether it needs to exist at all.

## Ship fast, then learn and iterate in public

We don't wait for perfect. We ship, we listen, and we improve in the open. We ask for your feedback and share what we learn as we build Jam because the best products are built with their users, not just for them.

## Do our best work

We hold ourselves to a high standard. We build Jam to help you move faster and ship more, and we bring genuine craft and care to everything we make.


# Video screen recording
Source: https://jam.dev/docs/video

Record a browser tab, window, or full desktop with console logs and network requests bundled in. Show the bug instead of typing it out.

You can use Jam to quickly record a video of your screen – along with all the technical details engineers need to troubleshoot and fix bugs. Unlike other screen recording tools, Jam's video recorder is purpose-built for product, engineering, support, and QA teams.

## What gets captured automatically

Every video recording includes:

* Console logs
* Fully inspectable network requests
* URL
* Timestamp and country
* Device, OS, and browser
* Viewport size
* Network speed

## Record a video

<Tabs>
  <Tab title="Browser tab recording">
    Tab recording captures exactly what's happening in a single browser tab. Use it for bugs that are self-contained within one page.

    <Steps>
      <Step title="Open the Jam extension">
        Click the Jam icon in your browser toolbar.
      </Step>

      <Step title="Select tab recording">
        Choose **Record tab** from the extension panel.
      </Step>

      <Step title="Configure your microphone (optional)">
        Toggle voiceover on if you want to narrate the recording. You can mute or unmute and switch microphones during the session.

        <Note>
          The first time you enable the microphone, your browser will prompt you to grant access. If you previously denied permission, go to `chrome://settings/content/siteDetails?site=chrome-extension://iohjgamcilhbgmhbnllfolmkmmekfmci` and set microphone to **Allow**.
        </Note>
      </Step>

      <Step title="Start recording">
        Click **Start** to begin. Jam captures everything in the active tab.
      </Step>

      <Step title="Annotate during recording">
        While recording, select the draw tool to annotate on screen. Drawn shapes fade away automatically after 3 seconds.

        <Warning>
          Annotations can only be added **during** recording, not after.
        </Warning>
      </Step>

      <Step title="Stop and share">
        Click **Stop** when you're done. Jam packages the video and diagnostics into a shareable link.
      </Step>
    </Steps>

    <Note>
      Tab recording does not capture the browser URL bar or any pop-up windows that open outside the tab (such as external login flows). Use desktop recording for those scenarios.
    </Note>
  </Tab>

  <Tab title="Desktop recording">
    Desktop recording captures an entire window or your full monitor. Use it for bugs that span multiple tabs, involve login pop-ups, or require the browser URL bar to be visible.

    <Steps>
      <Step title="Open the Jam extension">
        Click the Jam icon in your browser toolbar.
      </Step>

      <Step title="Select desktop recording">
        Choose the **Record desktop** option from the extension panel.
      </Step>

      <Step title="Choose what to record">
        When prompted by your browser, select the window or monitor you want to capture.
      </Step>

      <Step title="Start recording">
        Click **Start**. Jam captures the full window or screen, including the URL bar.
      </Step>

      <Step title="Stop and share">
        Click **Stop** to finish. Jam bundles console logs and network requests from every tab you interacted with during the recording (as long as Jam is installed in that browser window).
      </Step>
    </Steps>

    <Tip>
      Desktop recording is the right choice when a bug spans multiple tabs or windows. For example, an update appearing in one tab but not another. Jam captures console logs and network requests from all involved tabs simultaneously.
    </Tip>
  </Tab>
</Tabs>

## Blur sensitive content

Blur hides sensitive information in your video recording so private details stay secure when you share a Jam.

Here's how to use blur in your video recording:

1. Select tab or desktop recording from Jam extension
2. You can use blur before the recording starts by selecting the blur tool during countdown.
   <Note>
     Using blur before recording is available for tab recording only.
   </Note>
3. You can also use blur during recording. Clicking the blur tool pauses the recording, and you can start selecting elements you want to hide. To remove the blur, click again on the blurred element. When you're done, click **Done** and continue recording your video.
4. During window recording you can blur elements across multiple tabs

<Info>
  Blurring certain page elements like `iframe` and `canvas` is not supported.
</Info>

## Troubleshooting permissions on Mac

If you are using a Mac and are unable to record your desktop using Jam, follow these steps to fix it:

<Steps>
  <Step title="Open System Settings" />

  <Step title="Open Privacy & Security" />

  <Step title="Select Screen & System Audio Recording">
    On older macOS versions this is called **Screen Recording**.
  </Step>

  <Step title="Remove Google Chrome">
    If you don't see **Google Chrome** on the list, skip to the next step. If you see **Google Chrome** on the list, remove it using the minus icon.
  </Step>

  <Step title="Add Google Chrome">
    Add **Google Chrome** to the list using the plus icon.
  </Step>
</Steps>

## Incognito recording

Jam fully supports incognito mode. See [Incognito sessions](/docs/extension-setup#incognito-sessions) for setup steps.


# Webhooks and events
Source: https://jam.dev/docs/webhooks

Send Jam events to your own HTTPS endpoint, Zapier workflow, or n8n automation when a new Jam is created.

[Jam webhooks](https://jam.dev/s/settings/webhooks) send HTTP push notifications when a Jam is created. Use them to trigger CI builds, forward bug reports to external systems, post to Slack, file tickets automatically, or start any workflow that should react to a new Jam.

Webhooks are scoped to a Jam workspace. Configure them per workspace to match each team's tooling.

Jam supports the following webhook events:

* `jam.created`: fired when a new Jam is captured from any origin, including the Chrome extension, iOS app, dashboard, Fin (Intercom) integration, or Recording Link. Most integrations should subscribe to this event.
* `recording_link.created`: fired when a Recording Link is created in your workspace, from any origin — the dashboard, Chrome extension, iOS app, or the Fin (Intercom) integration. Use it to track or sync new Recording Links as they are issued.
* `intercom.recorder.recorded`: fired when a customer submits a screen recording through Jam's Intercom integration. Use this when tuning Fin AI Agent behavior after a recording arrives mid-conversation.
* `intercom.recorder.opted_out`: fired when a customer declines to record through Jam's Intercom integration. Use this when tuning Fin AI Agent behavior after a customer opts out.

If you are not configuring the Fin AI Agent, you only need `jam.created` (and `recording_link.created`, if you track Recording Links).

## Getting started

First, build a webhook consumer for Jam's webhook agent to call. You can deploy your own HTTP server, use a function platform like Netlify Functions, Vercel Functions, or Cloudflare Workers, or test with a service like [RequestBin](https://requestbin.com/). You can also use no-code and low-code tools such as [Zapier](https://zapier.com/) and [n8n](https://n8n.io/).

Once your consumer accepts requests, configure the webhook for your workspace.

### A minimal webhook consumer

<Warning>
  Webhook URLs are unauthenticated by default. Anyone who learns yours can POST to it. Verifying the `svix-signature` header confirms the request actually came from Jam. Skip verification only for throwaway test endpoints.
</Warning>

Jam signs webhook deliveries using the [Standard Webhooks](https://www.standardwebhooks.com/) format, powered by [Svix](https://docs.svix.com/receiving/verifying-payloads/why). The easiest way to verify is the official Svix SDK, which handles signature comparison, timestamp tolerance, and key rotation for you.

Deployed on Netlify, a basic consumer looks like this:

```ts theme={"theme":"css-variables"}
import { Webhook } from "svix";

export default async (request) => {
  const payload = await request.text();
  const headers = Object.fromEntries(request.headers);

  let event;
  try {
    const wh = new Webhook(Netlify.env.get("WEBHOOK_SECRET"));
    event = wh.verify(payload, headers); // throws on invalid signature
  } catch {
    return new Response(null, { status: 400 });
  }

  // Do something with the jam, e.g. post to Slack, file a ticket, kick off a CI run.

  return new Response(null, { status: 200 });
};

export const config = {
  path: "/my-jam-webhook",
};
```

If you can't use the Svix SDK, verify manually. The signature is HMAC-SHA256 over `${svix-id}.${svix-timestamp}.${body}`, base64-encoded, and may include multiple space-separated versions during key rotation:

```ts theme={"theme":"css-variables"}
import { createHmac, timingSafeEqual } from "node:crypto";

export default async (request) => {
  const payload = await request.text();
  const svixId = request.headers.get("svix-id");
  const svixTimestamp = request.headers.get("svix-timestamp");
  const svixSignature = request.headers.get("svix-signature");

  if (!svixId || !svixTimestamp || !svixSignature) {
    return new Response(null, { status: 400 });
  }

  const signed = `${svixId}.${svixTimestamp}.${payload}`;
  const secret = Netlify.env.get("WEBHOOK_SECRET").replace(/^whsec_/, "");
  const expected = createHmac("sha256", Buffer.from(secret, "base64"))
    .update(signed)
    .digest();

  const provided = svixSignature
    .split(" ")
    .filter((s) => s.startsWith("v1,"))
    .map((s) => Buffer.from(s.slice(3), "base64"));

  const valid = provided.some(
    (p) => p.length === expected.length && timingSafeEqual(p, expected),
  );
  if (!valid) {
    return new Response(null, { status: 400 });
  }

  // Handle the jam...

  return new Response(null, { status: 200 });
};

export const config = {
  path: "/my-jam-webhook",
};
```

### Creating a webhook

In the Jam dashboard, go to [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks) and click **Manage** to open the Webhook Portal. All endpoint configuration happens in the portal.

**Manual endpoint setup**

1. In the portal, click **Add Endpoint**.
2. Enter your endpoint URL.
3. Select the events to subscribe to.
4. Confirm creation.

**Intercom Fin connector**

Only relevant if you are tuning Jam's Intercom Fin AI Agent setup.

1. Select **Intercom Fin** from the webhook dropdown.
2. Paste the URL provided by Intercom.
3. Subscribe to `intercom.recorder.recorded` and `intercom.recorder.opted_out`.
4. Confirm creation.

After the endpoint is created, copy its **Signing secret** from the portal (it starts with `whsec_`). Store it as `WEBHOOK_SECRET`, or whatever name fits your stack, and use it to verify incoming requests.

The webhook is enabled by default. Capture a Jam to test it.

### Webhook Portal

The Webhook Portal, also under [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks), gives you operational visibility into every endpoint:

* **Delivery logs** for each attempt, with success and failure status.
* **Replay** for failed deliveries so you can re-fire a payload after fixing your consumer.
* **Signing secret** for verifying request authenticity.
* **Success rate** and delivery statistics over time.
* **Full payload inspection**, including headers and body, for any past delivery.

Use the portal to debug consumer issues and to confirm that retries land cleanly once your endpoint is back online.

## Webhook payload

The payload arrives as JSON over HTTPS with these headers:

```http theme={"theme":"css-variables"}
Accept-Charset: utf-8
Content-Type: application/json; charset=utf-8
svix-id: msg_loFOjxBNrRLzqYUf
svix-timestamp: 1715694798
svix-signature: v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=
```

| HTTP header      | Description                                                                                                                                                     |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `svix-id`        | Unique ID for this delivery. Use it as an idempotency key on your side.                                                                                         |
| `svix-timestamp` | Unix timestamp (seconds) when the delivery was signed.                                                                                                          |
| `svix-signature` | One or more space-separated `v1,<base64-hmac>` signatures of `${svix-id}.${svix-timestamp}.${body}`. Multiple versions are present during signing-key rotation. |

The event name is not sent as a header. Read it from your subscription config or inspect the payload shape directly.

### `jam.created` body

| Field           | Type    | Description                                                                                                                                                                                                                                  |
| --------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `jamId`         | string  | Unique ID of the Jam.                                                                                                                                                                                                                        |
| `jamUrl`        | string  | Shareable URL where the Jam can be viewed.                                                                                                                                                                                                   |
| `teamId`        | string  | ID of the workspace the Jam belongs to.                                                                                                                                                                                                      |
| `type`          | string  | One of `video`, `screenshot`, `sessionReplay`.                                                                                                                                                                                               |
| `createdAt`     | string  | ISO 8601 timestamp when the Jam was created.                                                                                                                                                                                                 |
| `title`         | string  | Jam title. May be absent.                                                                                                                                                                                                                    |
| `description`   | string  | Jam description. May be absent.                                                                                                                                                                                                              |
| `originalUrl`   | string  | Website URL where the Jam was captured. May be absent.                                                                                                                                                                                       |
| `origin`        | string  | Capture source, such as `recording_link`, `extension_chrome`, `mobile_ios`, `dashboard`, or `csup_intercom`. May be absent.                                                                                                                  |
| `isIncognito`   | boolean | Whether the Jam was captured in an incognito or private session. May be absent.                                                                                                                                                              |
| `author`        | object  | The user who captured the Jam. Includes `email` and may include `name`.                                                                                                                                                                      |
| `media`         | object  | URLs for the captured media. Includes `videoUrl`, `screenshotUrl`, and `thumbnailUrl` where applicable.                                                                                                                                      |
| `systemInfo`    | object  | Capture environment. Includes `browser` (`name`, `version`), `os` (`name`, `version`), and `screen` (`width`, `height`) where applicable.                                                                                                    |
| `recordingLink` | object  | Present only when the Jam was captured via a Recording Link. Includes `publicId`, `type` (`one_time` or `reusable`), and may include `recordingUrl`, `description`, and `reference`. Use `reference` to tie the Jam back to your own system. |

Required fields: `jamId`, `jamUrl`, `teamId`, `type`, `createdAt`, `author`, `media`, `systemInfo`.

### Example payload

```json theme={"theme":"css-variables"}
{
  "jamId": "2174add1-f7c8-44e3-bbf3-2d60b5ea8bc9",
  "jamUrl": "https://jam.dev/c/2174add1-f7c8-44e3-bbf3-2d60b5ea8bc9",
  "teamId": "dc844923-f9a4-40a3-825c-dea7747e57d6",
  "type": "video",
  "createdAt": "2026-05-14T12:53:18.084Z",
  "title": "Checkout button does nothing on Safari",
  "description": "Repro: add item to cart, hit checkout. Console shows a TypeError.",
  "originalUrl": "https://example.com/cart",
  "origin": "recording_link",
  "author": {
    "email": "alex@example.com",
    "name": "Alex Smith"
  },
  "media": {
    "videoUrl": "https://media.jam.dev/.../video.mp4",
    "thumbnailUrl": "https://media.jam.dev/.../thumb.jpg"
  },
  "systemInfo": {
    "browser": { "name": "Safari", "version": "17.4" },
    "os": { "name": "macOS", "version": "14.4.1" },
    "screen": { "width": 1512, "height": 982 }
  },
  "recordingLink": {
    "publicId": "aB3kZ4p",
    "type": "reusable",
    "recordingUrl": "https://example.com/cart",
    "description": "Checkout repro request",
    "reference": "ZD-48217"
  }
}
```

## FAQ

<AccordionGroup>
  <Accordion title="How does a Webhook work?">
    A webhook push is an `HTTP POST` request sent to a URL you choose. Jam triggers it automatically when a Jam is created.

    Your webhook consumer is an HTTP endpoint. It must:

    * Be available at a publicly accessible HTTPS, non-localhost URL.
    * Respond to the push with `HTTP 200` ("OK").

    Each message is attempted based on the following schedule, where each period starts after the preceding attempt fails:

    * Immediately
    * 5 seconds
    * 5 minutes
    * 30 minutes
    * 2 hours
    * 5 hours
    * 10 hours
    * 10 hours, in addition to the previous attempt

    If an endpoint is removed or disabled, delivery attempts to the endpoint are disabled as well.

    For example, an attempt that fails three times before succeeding is delivered roughly 35 minutes and 5 seconds after the first attempt.
  </Accordion>

  <Accordion />
</AccordionGroup>


# Webhook workflows
Source: https://jam.dev/docs/webhooks-workflows



Webhooks let you react to every new Jam. The workflow recipes below are common patterns, each with steps for one or more no-code platforms, along with a code variant.

Every workflow recipe assumes you already have a `jam.created` webhook endpoint. If you don't, see [Get Started with Webhooks](/docs/webhooks) first.

<CardGroup>
  <Card title="Open a PR from a Jam" icon="code-pull-request" href="#open-a-pr-from-a-jam">
    Hand a new Jam to an agent that reads the bug and opens a fix PR.
  </Card>

  <Card title="Notify Slack on incoming Jams" icon="slack" href="#notify-slack-on-incoming-jams">
    Post a Slack message whenever a customer captures a Jam.
  </Card>

  <Card title="Auto-file a Linear or Jira ticket" icon="ticket" href="#auto-file-a-linear-or-jira-ticket">
    Forward every new Jam to your tracker as a structured triage issue.
  </Card>

  <Card title="Prioritize Jams from key accounts" icon="crown" href="#prioritize-jams-from-key-accounts">
    Filter by author domain and route high-value reports straight to the team.
  </Card>
</CardGroup>

## Individual workflows

### Open a PR from a Jam

<Info>
  Hand a new Jam to a coding agent that pulls the full context through [Jam MCP](/docs/jam-mcp), writes a fix, and opens a PR for review. Best for code-addressable bugs from a small set of senders (yourself, your QA team, a beta user).
</Info>

<Warning>
  This workflow runs an LLM agent against your repository. Scope it to a sandbox repo or a narrow set of paths before any merges land near production.
</Warning>

The flow:

1. `jam.created` fires.
2. A GitHub Actions workflow (or any runner you control) runs with the Jam ID.
3. The runner invokes an agent that calls Jam MCP for the recording, logs, network requests, and transcript.
4. The agent writes a patch in a new branch and opens a PR that links back to the Jam.

<Tabs>
  <Tab title="GitHub Actions">
    <Steps>
      <Step title="Add a repository_dispatch workflow">
        Create `.github/workflows/jam-to-pr.yml` and trigger on `repository_dispatch` with event type `jam-created`.
      </Step>

      <Step title="Deploy a small webhook receiver">
        Stand up a function (Netlify, Vercel, Workers) that verifies the Jam signature and POSTs to GitHub's `repository_dispatch` API with the Jam ID in the client payload.
      </Step>

      <Step title="Register the receiver in Jam">
        Add the function URL in [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks) and subscribe to `jam.created`.
      </Step>

      <Step title="Invoke an agent inside the workflow">
        In the workflow, run [Claude Code](https://www.anthropic.com/claude-code) or your agent of choice with the Jam ID. The agent calls Jam MCP for context, edits files, commits, and opens a PR.
      </Step>

      <Step title="Scope the agent and gate the merge">
        Restrict the agent to specific paths, set required reviewers on the PR, and run the test suite before any human approves. 
      </Step>
    </Steps>

    ```yaml theme={"theme":"css-variables"}
    name: Jam to PR
    on:
      repository_dispatch:
        types: [jam-created]

    jobs:
      fix:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - name: Run agent
            env:
              JAM_ID: ${{ github.event.client_payload.jamId }}
              ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
              JAM_API_KEY: ${{ secrets.JAM_API_KEY }}
            run: ./scripts/run-agent.sh
    ```
  </Tab>

  <Tab title="n8n with an agent">
    <Steps>
      <Step title="Trigger on jam.created">
        Add a Webhook trigger and register the URL in Jam.
      </Step>

      <Step title="Call your agent">
        Use the HTTP Request node (or a Claude or OpenAI node) to send the Jam ID and ask the agent to call Jam MCP, write the fix, and push a branch.
      </Step>

      <Step title="Open the PR">
        Add a **GitHub → Create Pull Request** node with the branch name the agent pushed.
      </Step>

      <Step title="Notify the team">
        Add a Slack node so the PR URL lands in your engineering channel for review.
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Tip>
  Pair this with [Auto-file a Linear or Jira ticket](#auto-file-a-linear-or-jira-ticket): the ticket tracks the bug, the PR tracks the fix, and both reference the same Jam URL.
</Tip>

## Team workflows

### Notify Slack on incoming Jams

<Info>
  This workflow posts a Slack message whenever a Jam is captured through a [Recording Link](/docs/recording-links). Pair it with a public-facing Recording Link to collect feedback from your website and ping the team on every new report.
</Info>

<Tabs>
  <Tab title="Zapier">
    Use this [Zapier template](https://zapier.com/templates/details/notify-slack-of-incoming-recording-links-9cb456?secret=MTp0ZW1wbGF0ZTp5T3BoZkNNX2JJTE8wM3VJS2NIak1KZE5LZXdHaWV2V1pydmxLOUZNSVNVOnY3dWppbw) or follow the steps below.

    <Steps>
      <Step title="Create a Zap in Zapier">
        Open [Zapier's create Zap page](https://zapier.com/webintent/create-zap).
      </Step>

      <Step title="Select Webhooks by Zapier as the trigger">
        Choose **Webhooks by Zapier** as the trigger app, then select **Catch Hook**.

        <Frame>
          <img alt="Zapier trigger setup with Catch Hook selected for Webhooks by Zapier" />
        </Frame>
      </Step>

      <Step title="Copy the webhook URL">
        Open the **Test** tab and copy the webhook URL Zapier generated.

        <Frame>
          <img alt="Zapier Catch Hook test tab with a generated webhook URL and Copy button" />
        </Frame>
      </Step>

      <Step title="Create a jam.created webhook in Jam">
        Open [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks), add a new endpoint, paste the Zapier URL, and subscribe to `jam.created`.

        <Frame>
          <img alt="Webhook endpoint setup with jam.created selected in Jam" />
        </Frame>
      </Step>

      <Step title="Send an example event">
        Open the endpoint's testing view and click **Send Example**.

        <Frame>
          <img alt="Webhook endpoint testing view with Send Example and the event schema" />
        </Frame>
      </Step>

      <Step title="Test the Zapier trigger">
        Return to Zapier and test the trigger. Zapier shows a request record from the example event.

        <Frame>
          <img alt="Zapier test records view with request A selected from a webhook sample" />
        </Frame>
      </Step>

      <Step title="Add a Filter step for Recording Link origin">
        Add **Filter**. Select **Origin**, **Exactly matches**, and `recording_link` to send Slack messages only for Recording Link Jams.
      </Step>

      <Step title="Configure the Slack action">
        Add Slack as the action and map webhook fields into the message text.

        <Frame>
          <img alt="Zapier Slack message action with webhook fields mapped into message text" />
        </Frame>
      </Step>

      <Step title="Test and publish the Zap">
        Run a final test, then click **Publish**.

        <Frame>
          <img alt="Zapier toolbar with Test run and Publish buttons" />
        </Frame>
      </Step>
    </Steps>
  </Tab>

  <Tab title="n8n">
    <Steps>
      <Step title="Add a Webhook trigger node">
        Set the HTTP method to **POST** and copy the production URL.
      </Step>

      <Step title="Register the webhook in Jam">
        In [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks), add a new endpoint with the n8n URL and subscribe to `jam.created`.
      </Step>

      <Step title="Add an IF node to filter Recording Link Jams">
        Compare `{{$json["body"]["origin"]}}` to `recording_link`.
      </Step>

      <Step title="Add a Slack node">
        Use the **Post a message** operation and pull the Jam URL from `{{$json["body"]["jamUrl"]}}`.
      </Step>

      <Step title="Activate the workflow">
        Toggle the workflow to **Active** so n8n listens on the production URL.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Make">
    <Steps>
      <Step title="Create a scenario with a Custom webhook trigger">
        Add **Webhooks → Custom webhook** and copy the generated URL.
      </Step>

      <Step title="Register the webhook in Jam">
        In [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks), add the Make URL and subscribe to `jam.created`. Send an example event so Make learns the payload schema.
      </Step>

      <Step title="Add a Filter between trigger and Slack">
        Set the condition `origin` equals `recording_link`.
      </Step>

      <Step title="Add a Slack module">
        Use **Create a message** and reference `jamUrl`, `author.email`, and `title` in the message body.
      </Step>

      <Step title="Turn on the scenario">
        Click **Run once** to verify the flow, then toggle the scheduler on.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Code">
    Deploy this handler to Netlify Functions, Vercel, or Cloudflare Workers, then register the URL in [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks).

    ```ts theme={"theme":"css-variables"}
    import { Webhook } from "svix";

    export default async (request) => {
      const payload = await request.text();
      const headers = Object.fromEntries(request.headers);

      let event;
      try {
        const wh = new Webhook(process.env.WEBHOOK_SECRET);
        event = wh.verify(payload, headers);
      } catch {
        return new Response(null, { status: 400 });
      }

      if (event.origin !== "recording_link") {
        return new Response(null, { status: 200 });
      }

      await fetch(process.env.SLACK_WEBHOOK_URL, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          text: `New Jam from ${event.author.email}: <${event.jamUrl}|${event.title ?? "Untitled Jam"}>`,
        }),
      });

      return new Response(null, { status: 200 });
    };
    ```
  </Tab>
</Tabs>

### Auto-file a Linear or Jira ticket

<Info>
  Every `jam.created` event becomes a triage issue with the title, description, captured URL, and a link back to the Jam.
</Info>

<Tabs>
  <Tab title="Zapier">
    <Steps>
      <Step title="Trigger on jam.created">
        Use **Webhooks by Zapier → Catch Hook**, copy the generated URL, and register it in [**Settings → Webhooks**](https://jam.dev/s/settings/webhooks) with the `jam.created` event.
      </Step>

      <Step title="Send an example event from Jam">
        Open the endpoint in Jam and click **Send Example** so Zapier picks up the payload shape.
      </Step>

      <Step title="Add the Linear or Jira action">
        For Linear, choose **Create Issue**. For Jira, choose **Create Issue**.
      </Step>

      <Step title="Map the fields">
        * **Title**: `title` (fall back to `Bug from <author.email>` if empty)
        * **Description**: combine `description`, `originalUrl`, and `jamUrl` so the Jam is the first link in the ticket
        * **Status:** Triage
        * **Team or Project**: pick the triage destination
        * **Labels**: tag with the Jam `origin`
      </Step>

      <Step title="Publish the Zap">
        Run a test and turn on the Zap.
      </Step>
    </Steps>
  </Tab>

  <Tab title="n8n">
    <Steps>
      <Step title="Add a Webhook trigger node">
        Copy the production URL and register it in Jam with `jam.created`.
      </Step>

      <Step title="Add the tracker node">
        Use **Linear → Create Issue** or **Jira → Create Issue**. Authenticate with an API key.
      </Step>

      <Step title="Map the fields">
        * **Title**: `={{$json.body.title || "Bug from " + $json.body.author.email}}`
        * **Description**: include `{{$json.body.description}}`, the Jam link `{{$json.body.jamUrl}}`, and the captured URL `{{$json.body.originalUrl}}`
        * **Labels**: add the value of `{{$json.body.origin}}`
      </Step>

      <Step title="Activate the workflow">
        Send another example from Jam to confirm the ticket lands.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Make">
    <Steps>
      <Step title="Add a Custom webhook trigger">
        Copy the URL, register it in Jam with `jam.created`, and send an example event so Make learns the schema.
      </Step>

      <Step title="Add the Linear or Jira module">
        Pick **Create an Issue**. Authenticate with your tracker credentials.
      </Step>

      <Step title="Map the fields">
        Use the Jam payload for **Title**, **Description**, and **Labels**. Put the Jam URL on the first line of the description so reviewers click into the recording immediately.
      </Step>

      <Step title="Turn on the scenario">
        Verify with one example event, then enable the scheduler.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Code">
    The example below files a Linear issue. Swap the API call for Jira's REST endpoint if you use Jira.

    ```ts theme={"theme":"css-variables"}
    import { Webhook } from "svix";

    export default async (request) => {
      const payload = await request.text();
      const headers = Object.fromEntries(request.headers);

      let event;
      try {
        const wh = new Webhook(process.env.WEBHOOK_SECRET);
        event = wh.verify(payload, headers);
      } catch {
        return new Response(null, { status: 400 });
      }

      const title = event.title || `Bug from ${event.author.email}`;
      const description = [
        event.jamUrl,
        "",
        event.description ?? "",
        event.originalUrl ? `Captured on: ${event.originalUrl}` : "",
      ].join("\n");

      await fetch("https://api.linear.app/graphql", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: process.env.LINEAR_API_KEY,
        },
        body: JSON.stringify({
          query: `
            mutation IssueCreate($input: IssueCreateInput!) {
              issueCreate(input: $input) { success issue { id } }
            }
          `,
          variables: {
            input: {
              teamId: process.env.LINEAR_TEAM_ID,
              title,
              description,
            },
          },
        }),
      });

      return new Response(null, { status: 200 });
    };
    ```
  </Tab>
</Tabs>

## Customer workflows

### Prioritize Jams from key accounts

<Info>
  Route Jams captured on key-accountcaptured on key-account domains straight to the team and tag them with a priority label. Pair it with a Recording Link in your help center or status page so a VIP customer's report never sits in a queue.
</Info>

The flow:

1. `jam.created` fires.
2. Match the `originalUrl` host against a list of key-account domains, or look itMatch the `originalUrl` host against a list of key-account domains, or look it up in your CRM.
3. If matched, post to a high-priority Slack channel and create a `P0` ticket.
4. If not, fall through to your normal triage flow.

<Tabs>
  <Tab title="Zapier">
    <Steps>
      <Step title="Trigger on jam.created">
        Use **Webhooks by Zapier → Catch Hook** and register the URL in Jam.
      </Step>

      <Step title="Add a Paths step">
        Zapier's **Paths** branches on a condition. Create a path called **Key account**.
      </Step>

      <Step title="Filter the Key account path">
        Add a Filter: **Original URL** **Contains** `acme.com` **OR** `bigco.com`. Add one row per domain, or look the host upURL **Contains** `acme.com` **OR** `bigco.com`. Add one row per domain, or look the host up via [Zapier CRM integrations](https://zapier.com/apps/crm-connector/integrations).
      </Step>

      <Step title="Post to a priority Slack channel">
        In the Key account path, add **Slack → Send Channel Message** to `#vip-bugs`. Include the customer email, Jam title, and Jam URL.
      </Step>

      <Step title="Create a P0 ticket">
        Add **Linear → Create Issue** (or Jira). Set **Priority** to `Urgent` and add a `P0` label.
      </Step>

      <Step title="Add the fallback path">
        In the default path, file the Jam in your normal triage queue.
      </Step>

      <Step title="Publish the Zap">
        Test each path with an example event from Jam, then publish.
      </Step>
    </Steps>

    <Tip>
      If you maintain key accounts in HubSpot or Salesforce, swap the static domain list for a CRM lookup step before the Filter.
    </Tip>
  </Tab>

  <Tab title="n8n">
    <Steps>
      <Step title="Trigger on jam.created">
        Add a Webhook trigger and register the URL in Jam.
      </Step>

      <Step title="Branch on the capture URLcapture URL">
        Add an **IF** node. Condition: `{{$json.body.originalUrl}}` contains `originalUrl}}` contains `acme.com`. Use an OR group for additional domains.
      </Step>

      <Step title="Wire the true branch to Slack and Linear">
        Add **Slack → Post a message** to `#vip-bugs` and **Linear → Create Issue** with priority `Urgent`.
      </Step>

      <Step title="Wire the false branch to your default triage">
        Send the payload to your existing flow or leave it to a second webhook listener.
      </Step>

      <Step title="Activate the workflow">
        Send a few example events from Jam with different capture URLcapture URLs to confirm routing.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Code">
    ```ts theme={"theme":"css-variables"}
    import { Webhook } from "svix";

    const KEY_ACCOUNT_DOMAINS = new Set(["acme.com", "bigco.com"]);

    export default async (request) => {
      const payload = await request.text();
      const headers = Object.fromEntries(request.headers);

      let event;
      try {
        const wh = new Webhook(process.env.WEBHOOK_SECRET);
        event = wh.verify(payload, headers);
      } catch {
        return new Response(null, { status: 400 });
      }

      const host = event.originalUrl ? new URL(event.originalUrl).hostname : "";
      const isKeyAccount = [...KEY_ACCOUNT_DOMAINS].some(
        (d) => host === d || host.endsWith(`.${d}`),
      host = event.originalUrl ? new URL(event.originalUrl).hostname : "";
      const isKeyAccount = [...KEY_ACCOUNT_DOMAINS].some(
        (d) => host === d || host.endsWith(`.${d}`),
      );

      if (isKeyAccount) {
        await postToSlack("#vip-bugs", event);
        await createLinearIssue(event, { priority: 1, labels: ["P0"] });
      } else {
        await createLinearIssue(event, { priority: 3, labels: ["triage"] });
      }

      return new Response(null, { status: 200 });
    };
    ```
  </Tab>
</Tabs>

## More patterns

These flows share the same shape: pick up `jam.created`, call [Jam MCP](/docs/jam-mcp) for full context, then do something with it.

<CardGroup>
  <Card title="Auto-triage a folder" icon="layers">
    Cluster a folder of Jams (bug bash, beta cycle, customer flow) into grouped tickets instead of one per duplicate.
  </Card>

  <Card title="Design QA into a PR" icon="pen-tool">
    Turn a designer's walk-through into either a fix PR or routed Figma comments.
  </Card>

  <Card title="Recordings into artifacts" icon="file-text">
    Convert walk-throughs into doc drafts, test cases, or release notes with the MCP option to retrieve voice-over transcripts.
  </Card>
</CardGroup>

<Note>
  These patterns rely on Jam MCP for reading Jam content. See [Get Started with MCP](/docs/jam-mcp) for the tool reference.
</Note>


# Website
Source: https://jam.dev/docs/website

Open the main jam.dev website for product details, customers, and resources.



# Overview
Source: https://jam.dev/docs/whats-in-a-jam

See what every Jam captures and how to read it: visual context, custom logs, developer logs, and user events.

Every Jam includes developer information to help engineers debug faster. Get instant access to console logs, network data, and environment details without switching between tools or losing context.

## What's inside

<CardGroup>
  <Card title="Visual context">
    Screenshots and screen recordings with annotation tools
  </Card>

  <Card title="Custom Logs">
    URL, timestamp, device info, browser version, OS and more
  </Card>

  <Card title="DevTools" href="/devtools">
    Console logs and complete network request details
  </Card>

  <Card title="User events">
    Clicks, navigation events, and more
  </Card>

  <Card title="MCP" href="/jam-mcp" alt="MCP logo">
    Send DevTools context to AI agents so they can inspect logs, network requests, and user events.
  </Card>
</CardGroup>

## Layouts

Switch between side and bottom layouts to fit your workflow:

<Tabs>
  <Tab title="DevTools visible">
    DevTools appear on the right side in the properties panel for wide-screen debugging. Ideal when you need to see both the captured page and technical details simultaneously.

    <Frame>
      <img alt="Jam With Devtools" />
    </Frame>
  </Tab>

  <Tab title="Content only">
    Hide DevTools to show only the visual captured content and activity including title, description, and comments.

    <Frame>
      <img alt="Jam Without Devtools" />
    </Frame>
  </Tab>
</Tabs>

## Embed Figma designs

You can paste Figma links into Jam, and engineers will see the Figma frame side by side with your initial bug report.

<Steps>
  <Step title="Capture a visual bug">
    Use Jam to capture the bug on your screen.
  </Step>

  <Step title="Paste a Figma link in the description">
    In the Jam description, paste a Figma link.
  </Step>

  <Step title="Create the Jam">
    Click **Create**.
  </Step>

  <Step title="Open the embedded Figma">
    Open the new Jam. You'll see a Figma icon at the bottom. Click it to reveal the Figma embed.
  </Step>
</Steps>

Engineers don't need to open another tab to see intended designs.


# Workspace setup
Source: https://jam.dev/docs/workspace-setup

Set up a shared workspace so your whole team can capture, organize, and route bugs to the tools you already use.

<img alt="Jam workspace header with member avatars, the Invite and + Create Jam buttons, and folder tabs for Internal Team and Customer Support" />

A Jam workspace gives your whole team a shared place to capture, organize, and debug issues together.

## Set up your workspace

If you haven't created a workspace yet, sign in at [jam.dev](https://jam.dev/login) and create one. Workspaces [support domain-based discovery](#workspace-visibility). Anyone with a matching email domain can find and request to join your workspace automatically.

## Invite members

<Steps>
  <Step title="Open the dashboard">
    Log in to [jam.dev](https://jam.dev/login) and go to your workspace.
  </Step>

  <Step title="Click Invite">
    Click **Invite** in the dashboard header.
  </Step>

  <Step title="Send invitations">
    Invite members by email address or share the workspace invite link.
  </Step>

  <Step title="Assign roles (optional)">
    Adjust member roles and permissions as needed. See [Members and Roles](/docs/members-and-roles) for the full breakdown of available roles.
  </Step>
</Steps>

## Workspace visibility

<img alt="Workspace visibility setting toggled on, allowing anyone with an @acme-corp.com email to join" />

Workspace visibility controls whether your workspace appears to colleagues in your company. When enabled, anyone who signs up or logs in with your company email instantly sees an option to join your workspace.

### Managing Workspace Visibility

Workspace visibility controls where your workspace appears:

* **Sign-up** for new users with your company email domain
* **In-product prompts** for existing Jam users with your company email domain

<Info>
  Users join as **Viewers** and can be promoted to other roles by workspace admins
</Info>

#### Default Behavior

Workspace visibility availability depends on your plan:

* **Free and Team plan**: enabled by default for all workspaces
* **Enterprise Plan**: Not available. Enterprise workspaces use advanced security and access controls.
* **Legacy Plans**: Disabled by default. Upgrade to the new Team plan to enable this option

### Configure

Only workspace admins can change visibility settings:

<Steps>
  <Step title="Open Settings">
    Go to [**Settings**](https://jam.dev/s/settings).
  </Step>

  <Step title="Find the Workspace visibility section" />

  <Step title="Toggle visibility on or off">
    Set **Workspace visibility** to **On** or **Off**.
  </Step>
</Steps>

<Tabs>
  <Tab title="Visibility on">
    <img alt="Workspace visibility toggle set to on for the @acme-corp.com domain" />

    **New users with your @[company.com](http://company.com) email**\
    Anyone signing up or logging in with your company email instantly sees the option to join your workspace.

    <img alt="We found your team on Jam discovery modal, prompting a new signup to join the Design Team or QA for Product X workspace" />
  </Tab>

  <Tab title="Visibility off">
    <img alt="Workspace visibility setting toggled off" />

    **New users with your @[company.com](http://company.com) email**\
    Your workspace is hidden from automatic discovery.
  </Tab>
</Tabs>

### Privacy considerations

Workspace discoverability is separate from [access controls](/docs/access-controls), which determine who can view your Jams:

* **Workspace visibility**: Controls whether users with your domain can find and join your workspace
* **Access Controls**: Controls who can view your Jams and folders

<Info>
  Workspace admins get notified each time someone joins.
</Info>

You can have discoverability enabled while still keeping strict access controls for your content.


# Request Customer Screen Recordings from Zendesk
Source: https://jam.dev/docs/zendesk

Request screen recordings from customers inside Zendesk tickets and link each Jam back to the original support thread.

Jam works with Zendesk through Recording Links, shareable URLs you generate in the Jam browser extension and paste directly into a ticket reply. When a customer clicks the link and records, the resulting Jam arrives in your dashboard with a reference back to the original Zendesk ticket.

## How to request a Jam from Zendesk

<Steps>
  <Step title="Create a Recording Link">
    Open the Jam browser extension and click **Request a Recording**.
  </Step>

  <Step title="Paste the ticket URL as the link name">
    Copy the Zendesk ticket URL (e.g., `https://yourcompany.zendesk.com/agent/tickets/ABC-12345`) and paste it into the Recording Link name field. This creates a reference between the Jam and the ticket for easy lookup later.
  </Step>

  <Step title="Generate the link">
    Click **Create link**. The link is automatically copied to your clipboard.
  </Step>

  <Step title="Share the link in the ticket">
    Paste the Recording Link into your Zendesk reply and send it to the customer.
  </Step>

  <Step title="Receive the recording">
    When the customer records and submits, you receive an email notification. The Jam appears in your dashboard with a reference to the Zendesk conversation.
  </Step>
</Steps>

***

## What customers experience

The recording flow requires no downloads or account:

1. The customer clicks the Recording Link and it opens in their browser.
2. They click **Start Recording** and capture the issue on screen.
3. The recording uploads automatically and notifies you immediately.

***

## What data is collected

Each Jam submitted through a Recording Link includes:

* **Screen recording**: a video of the customer's screen
* **System metadata**: browser version, operating system, screen resolution
* **Reference URL**: the Zendesk ticket URL you attached when creating the link

<Note>Console logs and network requests are not captured by default. To collect them, connect your domain. See [Connect your domain](/docs/custom-recording-domain).</Note>

***

## Tips for Zendesk workflows

Use the `jam-reference` URL parameter to automatically attach the ticket URL to every Jam, even when using a reusable link:

```text theme={"theme":"css-variables"}
https://recorder.jam.dev/QrBnf3s?jam-reference=https%3A%2F%2Fyourcompany.zendesk.com%2Fagent%2Ftickets%2FABC-12345
```

<Tip>Create a reusable Recording Link for your support team and save it as a Zendesk macro. Agents can insert it into any ticket reply with a single click.</Tip>