# Jam

> <img src="

---

# Source: https://jam.dev/docs/administration/access-controls.md

# Access Controls

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FuWI0PTbJVv8NAzivMIue%2Fimage.png?alt=media&#x26;token=7bac7ad8-2d92-4f87-94f2-1d6c85522d5f" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Available to workspaces on our [Team](https://jam.dev/pricing) or [Enterprise](https://jam.dev/pricing) plans.
{% endhint %}

### Overview

Control default access for all existing and new Jams created by your team:

1. **Public**: Anyone with the link can view&#x20;
2. **Private**: Only people with verified company domains can view

Your team's access controls automatically configure based on your email domain:

* **Company email domains**: Private access (login required)
* **Personal email domains**: Public access (anyone with link)

You can modify the default access controls in your team settings page. Additionally you can override default workspace settings for individual Jams:

{% tabs %}
{% tab title="Default Team Workspace Settings" %}
Control default access for all existing and new Jams created by your team:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1jE5YAnsLJ5OqwRxgH0V%2FSetting_%20Access%20Controls%20Workspace%20Level.png?alt=media&#x26;token=325cfc67-6323-48fd-8ebe-fb9bed342e70" alt=""><figcaption></figcaption></figure>

1. **Go to your team settings**
2. **Find the Default link access**
3. **Select who can access your team's Jam links**
   1. Public: Anyone with the link can view
   2. Private: Only people with verified company domains can view

*Only admins can modify these settings in your team's workspace settings.*
{% endtab %}

{% tab title="Individual Jam Control" %}
Override default workspace settings for individual Jams:

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBJutZZfRFm2TocYw5PqW%2Fteam-link-privacy.gif?alt=media&#x26;token=f21855d0-b530-42ee-9272-4d57f6c7d4a0" alt="" width="375"><figcaption></figcaption></figure></div>

1. **Open any Jam**
2. **Click the share button**&#x20;
3. **Choose**
   1. Public: Anyone with the link can view
   2. Private: Only people with verified company domains can view
4. **Add specific email addresses** for targeted sharing or copy the Jam link

*When you share by email, recipients get automatic notifications.*
{% endtab %}
{% endtabs %}

### FAQs

<details>

<summary>What's the difference between public and private Jam sharing?</summary>

Public sharing lets anyone with the link view the Jam (no login required). Private sharing requires users to log in and be part of your workspace.

</details>

---

# Source: https://jam.dev/docs/jam-for-customer-support/advanced-data-protection-for-customer-support-jams-auto-blur.md

# Advanced Data Protection for  Customer Support Jams (Auto-blur)

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FVRlbi4cluvMUjt9I0Yxb%2F2025-10-29_15-16-03.gif?alt=media&#x26;token=11240334-eb29-404f-9d33-0021d81764a4" alt=""><figcaption></figcaption></figure>

## How it works

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

1. Sensitive elements are blurred in real time as they are recorded, and sensitive information is redacted from the console logs.
2. Only the blurred version is captured—sensitive data never reaches Jam's servers.
3. The final Jam shows blurred content exactly as the customer saw it during recording; the console logs will show \<redacted> instead of the sensitive data.

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

**Applies to:** Jams you request from your customers via Intercom or Recording Link

{% hint style="info" %}
By default, Jam recognizes the same privacy selectors used by popular tools like FullStory, Hotjar, LogRocket, Sentry, and others. If you're already using these tools, your existing privacy setup works automatically with Jam; if not, it's as easy as adding our selector, or providing us with your own.
{% endhint %}

***

## Setup

**Note:** Blurring is enabled by default once the snippet is installed.

{% hint style="warning" %}
**Blurred content is only supported on sites with verified Jam.js installations.**

Follow the [Recording Links setup guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs) \[5 mins] before proceeding.
{% endhint %}

### Quickstart

#### - Want to blur something?

Use Jam.js data attributes to opt in:

```
<span data-jam-blur>{ccNumber}</span>
```

Or tell Jam.js about your privacy selectors:

```
<meta name="jam:blur" content=".secret-stuff" />
```

Or if you're using the SDK:

```
jam.initialize({ blurSelectors: ".secret-stuff" });
```

#### - Want to unblur something?

Use Jam.js data attributes to opt out:

```
<span class="cc-number" data-jam-blur="no">{ccNumber}</span>
```

***

### What gets blurred automatically

Jam recognizes privacy selectors from popular session replay and analytics tools. If you already use any of these tools with privacy controls in place, those same elements will be automatically blurred in Jam recordings:

#### Standard selectors

* **Jam**: `[data-jam-blur]`
* **rrweb**: `.rr-block`, `.rr-mask`, `.rr-ignore`&#x20;
* **Additional selectors:**<br>

  > **Standard HTML autocomplete attributes**
  >
  > * `autocomplete="cc-number"` - credit card numbers
  > * `autocomplete="cc-exp"` - credit card expiration
  > * `autocomplete="cc-csc"` - credit card security code
  > * `autocomplete="tel"` - phone numbers
  > * `autocomplete="email"` - email addresses
  >
  > **Common name/id patterns for sensitive fields:**
  >
  > **Social Security Numbers:**
  >
  > * `ssn`, `social-security`, `social_security_number`, `tax-id`
  >
  > **Bank Account:**
  >
  > * `account-number`, `account_number`, `routing-number`, `iban`, `swift`
  >
  > **Credit Cards:**
  >
  > * `card-number`, `cardnumber`, `cc-number`, `creditcard`
  > * `cvv`, `cvc`, `security-code`, `card-code`
  >
  > **Photo IDs/Passports:**
  >
  > * `passport`, `passport-number`, `drivers-license`, `id-number`, `national-id`
  >
  > **Driver's License:**
  >
  > * `license-number`, `drivers-license`, `dl-number`

#### Session replay tools

* **FullStory**: `.fs-exclude`, `.fs-mask`, `.fs-block`, `.fs-unmask` (unblur)
* **Hotjar**: `.data-hj-suppress`, `.data-hj-masked`, `[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 for your product

If you are using `@jam.dev/recording-links/sdk`: pass your custom selectors into `initialize(...)` using the `blurSelectors` key:

```
import * as jam from "@jam.dev/recording-links/sdk";

// `blurSelectors` can be a static string:
jam.initialize({ blurSelectors: ".my-custom-blur-class" });

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

// or a runtime function that evaluates to either of the above
jam.initialize({
  blurSelectors: () => `.my-${Math.ceil(Math.random() * 100)-blur-class`,
});
```

If you are using `<script type="module" ...>` to embed `recorder.js` and `capture.js`: use `<meta>` tags to provide your selectors to Jam.js:

```
<html>
  <head>
    ...
    <meta name="jam:blur" content=".my-custom-blur-class" />
    <meta name="jam:blur" content=".blur-class-1,.blur-class-2" />
  </head>
  <body>
    ...
  </body>
</html>
```

***

### Opt out of blurring for specific elements

If Jam.js is blurring an element it oughtn't, you can use `[data-jam-blur="no"]` to disable blurring:

```
<div class=".rr-block" data-jam-blur="no">
  Blurred in rrweb, but not in Jam
</div>
```

**Selector priority:** Manual opt-out overrides all blurrable matches, whether from a default or custom selector.

***

### Test your setup

Before sharing Recording Links with customers, verify that blurring works correctly:

1. Create a Recording Link with your verified recording URL selected
2. Click your own link and start a recording session
3. Navigate to pages with sensitive content

**What to look for:**

* If sensitive content is blurred during the recording session, it won't appear in the final Jam ✓
* If you can see sensitive content clearly while recording, it will appear in the Jam

This real-time preview shows you exactly what will be captured.

### Limitations

* Content in iframes must be blurred altogether, or not at all—we cannot selectively blur inside an iframe
* Flashes of unblurred content may occur during captured pageloads if your UI initializes before Jam.js. If you see flashes of unblurred content when refreshing a page during a recording, try moving Jam.js initialization earlier in your page's execution, or `await`ing it before displaying sensitive data.

<br>

---

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

# AI Policy

## Building Jam AI

Jam AI is designed to help teams move faster by automating repetitive tasks and enhancing the clarity of bug reports. Whether you're generating ticket descriptions, capturing detailed reproduction steps, or need help debugging, Jam AI keeps you focused on solving issues rather than spending time documenting them. Learn more about our approach below.

### **Our Approach**

Jam's AI features are powered by third-party AI models that help you create and resolve bugs faster. Key features — including automatic ticket creation, reproduction step generation, and debugger — leverage AI to speed up your workflow. We're continually working to improve Jam AI by developing smarter models that better understand debugging patterns and technical documentation.

### Data and privacy

We know how important it is to keep your data safe. Our AI model development process is built to protect 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 team

When working with third-party AI providers, we:

* Do not allow them to train their models on customer data uploaded or created with Jam
* Limit how long vendors can store data — third-party providers may process data temporarily to enable AI features
* Take steps to de-identify and anonymize content, removing sensitive information from processed text

For general information about security at Jam visit [security-privacy-and-compliance-policy](https://jam.dev/docs/company/security-privacy-and-compliance-policy "mention")

---

# Source: https://jam.dev/docs/integrations/asana.md

# Asana

{% embed url="<https://www.youtube.com/watch?v=WowvBgxDJAY>" %}

You can connect Asana and Jam in order to instantly create Asana tasks right from Jam's browser extension. Every Asana task you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant Asana fields right from Jam – like assignee, project, tags and more. Our goal is to make you 20x faster at logging bugs to Asana.

## How to use Jam + Asana

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20;     [getting-started](https://jam.dev/docs/get-started/getting-started "mention")

2. Next, capture your bug with Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FegyVq2w1jJtmOaeDs8QN%2Fasana-1.gif?alt=media&#x26;token=a34cac33-1e5a-481a-bb64-ec16ca8977b0" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture. Click on "Link you can share" and change it to Asana.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJRp9GQwpFq1bgbtqq0Uu%2Fasana-2.gif?alt=media&#x26;token=4a3e0634-2dea-4aee-b8f9-557f112b1289" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Asana.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FYsoYDICODFFgSt2sOFdu%2Fasana-3.gif?alt=media&#x26;token=43ddd71c-9767-411d-81f9-8a4d83ddf20f" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Asana, you will be able to setup your Asana task right from Jam. Choose the workspace, project, assignee, tags, etc., right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FFhfioZ6fT1mOS1m9iphL%2Fasana-4.gif?alt=media&#x26;token=eac14a3b-976c-48f1-bbf6-3ba9e0a5fe34" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields"  to manage which fields from Asana are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FG8az3JI3Y6lem18joybj%2Fasana-5.gif?alt=media&#x26;token=e20bf845-cfac-4587-814f-4f4a6d43cb0a" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create task" and once Jam creates your Asana task, it will automatically open in a new tab. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FPFPnuegT5pRAueswri76%2Fasana-6.gif?alt=media&#x26;token=9e908592-24ef-4388-ac6f-b98044346303" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to Asana

You can automatically create Asana tasks from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to an Asana task.
2. Click "Send to App" and select Asana.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fcj6zuLZp3oqHtWVrXwdB%2Fasana-tools-1.gif?alt=media&#x26;token=3976eeec-193f-47d0-87b3-d6317cc91b39" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Asana before, it will first redirect you to log in with Asana.
4. Enter the details of your Asana task: workspace, project, assignee, tags, etc.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FaxrPwxadQeuzaLsc5pA6%2Fasana-tools-2.gif?alt=media&#x26;token=1a63317f-6d2b-4b50-b3f2-7855e7ee339c" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields"  to manage which fields from Asana are shown in Jam.
6. Click "Create task" to create your Asana task.&#x20;

---

# Source: https://jam.dev/docs/administration/audit-logs.md

# Audit Logs

{% hint style="info" %}
Available to workspaces on our [Enterprise](https://jam.dev/pricing) plans.
{% endhint %}

### Overview

Audit logs give you complete visibility into your team's Jam workspace activity. Track who's doing what, when changes happen, and maintain accountability across your team. Essential for security oversight, compliance requirements, and team management.

### 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:** Maintain detailed records for security audits and regulatory requirements

#### What's Tracked

Audit logs capture three main categories of workspace activity:

| Activity Type     | What's Logged                                                                      |
| ----------------- | ---------------------------------------------------------------------------------- |
| Access Control    | Changes to team, folder, and individual Jam permissions                            |
| Membership Events | User invitations, removals, and role modifications                                 |
| Settings Changes  | Data retention updates, AI feature toggles, and Changes in workspace configuration |

### How It Works

Every significant action in your workspace gets automatically logged with:

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

This creates a complete audit trail that helps you understand workspace evolution and identify any unauthorized changes.

***

### Getting Started

Reach out to our team to enable audit logs for your team

<a href="https://jam.dev/contact-sales" class="button primary">Contact</a>

---

# Source: https://jam.dev/docs/jam-for-customer-support/auto-blur-sensitive-info-in-customer-jams.md

# Auto-blur sensitive info in Customer Jams

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FVRlbi4cluvMUjt9I0Yxb%2F2025-10-29_15-16-03.gif?alt=media&#x26;token=11240334-eb29-404f-9d33-0021d81764a4" alt=""><figcaption></figcaption></figure>

## How it works

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

1. Sensitive elements are blurred in real-time as they record
2. Only the blurred version is captured—sensitive data never reaches Jam's servers
3. The final Jam shows blurred content exactly as the customer saw it during recording

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

**Applies to:** Jams you request from your customers via Intercom or Recording Link

{% hint style="info" %}
By default, Jam recognizes the same privacy selectors used by popular tools like FullStory, Hotjar, LogRocket, Sentry, and others. If you're already using these tools, your existing privacy setup works automatically with Jam; if not, it's as easy as adding our selector, or providing us with your own.
{% endhint %}

***

## Setup

**Note:** Blurring is enabled by default once the snippet is installed.

{% hint style="warning" %}
**Blurred content is only supported on sites with verified Jam.js installations.**

Follow the [Recording Links setup guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs) \[5 mins] before proceeding.
{% endhint %}

### Quickstart

#### - Want to blur something?

Use Jam.js data attributes to opt in:

```
<span data-jam-blur>{ccNumber}</span>
```

Or tell Jam.js about your privacy selectors:

```
<meta name="jam:blur" content=".secret-stuff" />
```

Or if you're using the SDK:

```
jam.initialize({ blurSelectors: ".secret-stuff" });
```

#### - Want to unblur something?

Use Jam.js data attributes to opt out:

```
<span class="cc-number" data-jam-blur="no">{ccNumber}</span>
```

***

### What gets blurred automatically

Jam recognizes privacy selectors from popular session replay and analytics tools. If you already use any of these tools with privacy controls in place, those same elements will be automatically blurred in Jam recordings:

#### Standard selectors

* **Jam**: `[data-jam-blur]`
* **rrweb**: `.rr-block`, `.rr-mask`, `.rr-ignore`

#### Session replay tools

* **FullStory**: `.fs-exclude`, `.fs-mask`, `.fs-block`, `.fs-unmask` (unblur)
* **Hotjar**: `.data-hj-suppress`, `.data-hj-masked`, `[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 for your product

If you are using `@jam.dev/recording-links/sdk`: pass your custom selectors into `initialize(...)` using the `blurSelectors` key:

```
import * as jam from "@jam.dev/recording-links/sdk";

// `blurSelectors` can be a static string:
jam.initialize({ blurSelectors: ".my-custom-blur-class" });

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

// or a runtime function that evaluates to either of the above
jam.initialize({
  blurSelectors: () => `.my-${Math.ceil(Math.random() * 100)-blur-class`,
});
```

If you are using `<script type="module" ...>` to embed `recorder.js` and `capture.js`: use `<meta>` tags to provide your selectors to Jam.js:

```
<html>
  <head>
    ...
    <meta name="jam:blur" content=".my-custom-blur-class" />
    <meta name="jam:blur" content=".blur-class-1,.blur-class-2" />
  </head>
  <body>
    ...
  </body>
</html>
```

***

### Opt out of blurring for specific elements

If Jam.js is blurring an element it oughtn't, you can use `[data-jam-blur="no"]` to disable blurring:

```
<div class=".rr-block" data-jam-blur="no">
  Blurred in rrweb, but not in Jam
</div>
```

**Selector priority:** Manual opt-out overrides all blurrable matches, whether from a default or custom selector.

***

### Test your setup

Before sharing Recording Links with customers, verify that blurring works correctly:

1. Create a Recording Link with your verified recording URL selected
2. Click your own link and start a recording session
3. Navigate to pages with sensitive content

**What to look for:**

* If sensitive content is blurred during the recording session, it won't appear in the final Jam ✓
* If you can see sensitive content clearly while recording, it will appear in the Jam

This real-time preview shows you exactly what will be captured.

### Limitations

* Content in iframes must be blurred altogether, or not at all—we cannot selectively blur inside an iframe
* Flashes of unblurred content may occur during captured pageloads if your UI initializes before Jam.js. If you see flashes of unblurred content when refreshing a page during a recording, try moving Jam.js initialization earlier in your page's execution, or `await`ing it before displaying sensitive data.

<br>

---

# Source: https://jam.dev/docs/integrations/azure-devops.md

# Azure DevOps

You can connect Azure DevOps and Jam in order to instantly create Azure DevOps issues right from Jam's browser extension. Every Azure DevOps issue you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant Azure DevOps fields right from Jam – like project, team, priority and more. Our goal is to make you 20x faster at logging bugs to Azure DevOps.

Step by step instructions below - or watch this 2 min tutorial to start creating Jams in Azure DevOps.

{% embed url="<https://www.youtube.com/watch?v=tlB6JhnyOCA>" %}

## How to use Jam + Azure DevOps

1. First, you'll need to make sure you have the access settings in your Azure DevOps organization enabled. Go to your organization settings, and under Policies enable the "Third-party application access via OAuth".
2. Then, you need to have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20;     [getting-started](https://jam.dev/docs/get-started/getting-started "mention")

2. Next, capture your bug with Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FiFA9UaSdD43TtKmHlQnP%2FAzure-1.gif?alt=media&#x26;token=9ed6d21b-c658-4460-a6d3-4aefb69093e5" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to Azure DevOps.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FSc2EWZuOm6CmmZTKDZos%2FAzure-2.gif?alt=media&#x26;token=2f01e213-b4d5-4eec-8beb-8294fc4404f4" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Azure DevOps.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjWnTcp6ddzbHPO6OILcl%2FAzure-3.gif?alt=media&#x26;token=ee335cba-c203-424d-8ba7-76b867ffdbbd" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Azure DevOps, you will be able to setup your Azure DevOps issues right from Jam.\
   Choose the project, team, priority, assignees, etc., right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FNrIuAHvACsX8PPE7Ck2s%2FAzure-4.gif?alt=media&#x26;token=92773ac8-ce94-4a41-9865-bd4dc32f2299" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields"  to manage which fields from Azure DevOps are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBneAOARkKZqDiADWNCsK%2FAzure-5.gif?alt=media&#x26;token=edbae283-9cf8-4148-94dd-5a9efa30513f" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create issue" and once Jam creates your Azure DevOps issue, it will automatically open in a new tab. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FN0DP6pLB10FjqqZw8pZC%2FAzure-6.gif?alt=media&#x26;token=bbf4b015-e484-48d8-91b2-c837a4534932" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to Azure DevOps

You can automatically create Azure DevOps issues from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to an Azure DevOps issue.
2. Click "Send to App" and select Azure DevOps.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FwQenXKI6ORoi7Ar93clE%2FAzure-7.gif?alt=media&#x26;token=704e1a59-07d5-4046-b769-9fb498212f55" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Azure DevOps before, it will first redirect you to log in with Azure DevOps.
4. Enter the details of your Azure DevOps issue: project, team, priority, etc<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F4Syen27hX21LOENZtj4o%2FAzure-8.gif?alt=media&#x26;token=6f985e51-140c-4667-b40d-6d1ef9a78853" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields"  to manage which fields from Azure DevOps are shown in Jam.
6. Click "Create issue" to create your Azure DevOps issue.&#x20;

---

# Source: https://jam.dev/docs/record-a-jam/browser-support.md

# Browser support

## Browser support

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.

## Feature Support

<table><thead><tr><th width="123">Browser</th><th>Console Logs</th><th>Network Requests</th><th>WebSockets</th></tr></thead><tbody><tr><td>Chrome</td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td></tr><tr><td>Edge</td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td></tr><tr><td>Arc</td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td></tr><tr><td>Brave</td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td></td></tr><tr><td>Opera</td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td><td><span data-gb-custom-inline data-tag="emoji" data-code="2705">✅</span></td></tr></tbody></table>

## Download

Download the Jam extension for Chromium browsers:&#x20;

{% embed url="<https://chrome.google.com/webstore/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci>" %}

---

# Source: https://jam.dev/docs/integrations/clickup.md

# ClickUp

{% embed url="<https://www.youtube.com/watch?v=KNzYkHroDtQ>" %}

You can connect ClickUp and Jam in order to instantly create ClickUp tasks right from Jam's browser extension. Every ClickUp task you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant ClickUp fields right from Jam – like workspace, folder, list and more. Our goal is to make you 20x faster at logging bugs to ClickUp.

### How to use Jam + ClickUp <a href="#how-to-use-jam--jira" id="how-to-use-jam--jira"></a>

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20; [getting-started](https://jam.dev/docs/get-started/getting-started "mention")

2. Next, capture your bug with Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fw94CmBfns1FnrDb5SBMA%2Fclickup-1.gif?alt=media&#x26;token=41483540-a26b-4613-be2c-ae259a43c87d" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to ClickUp.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FUugErikNAlBg99b2hTTs%2Fclickup-2.gif?alt=media&#x26;token=6bee9776-757e-44db-8abb-2251cf7f1a6a" alt="" width="375"><figcaption></figcaption></figure></div>
4. &#x20;Jam will guide you through authenticating with ClickUp.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F7xbVxHm1ZugQaN2uDKro%2Fclickup-3.gif?alt=media&#x26;token=3385c109-1d74-485b-bf07-8caee544cc39" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to ClickUp, you will be able to setup your ClickUp task right from Jam. Choose the workspace, folder, list, assignee, etc., right from Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkpfFqoE5Bu315lT3to4l%2Fclickup-4.gif?alt=media&#x26;token=f854263d-4ba5-4cc3-b97d-60f31e8b7c7f" alt="" width="375"><figcaption></figcaption></figure></div>

   *Note: ClickUp workspace guests can also create Jams. In their case the Space field will default to the shared place they have access to, while they can continue filling out the rest of the public fields.*
6. Pro tip: you can click "Edit fields" to manage which fields from ClickUp are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FE7P0Ve7aXkANYSu0fW4I%2Fclickup-5.gif?alt=media&#x26;token=6cbdc593-7827-41d0-beae-b8841660b448" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create task" and once Jam creates your ClickUp task, it will automatically open in a new tab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBhosArCFdKiJE3LXsdWO%2Fclickup-6.gif?alt=media&#x26;token=82e3288e-9893-469a-ad12-19d0ab5e0530" alt="" width="375"><figcaption></figcaption></figure></div>

### How to send existing Jams to ClickUp <a href="#how-to-send-existing-jams-to-jira" id="how-to-send-existing-jams-to-jira"></a>

You can automatically create ClickUp tasks from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a ClickUp task.
2. Click "Send to App" and select ClickUp .<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FDCvIb6hgVzpqWMDUASWK%2Fclickup-tools-1.gif?alt=media&#x26;token=9ce74fa4-d1ba-4bc2-b946-912ef6f3ec98" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + ClickUp before, it will first redirect you to log in with ClickUp.
4. Enter the details of your ClickUp task: workspace, folder, list, assignee, etc.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FET7hxCEUb2qAxpHGe0t7%2Fclickup-tools-2.gif?alt=media&#x26;token=0e3dc440-be10-4d84-8128-defc1cc708d1" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields" to manage which fields from ClickUp are shown in Jam.
6. Click "Create task" to create your ClickUp  task.

### How to connect multiple ClickUp workspaces to Jam <a href="#how-to-connect-multiple-jira-sites-to-jam" id="how-to-connect-multiple-jira-sites-to-jam"></a>

A Jam account or team workspace can connect to multiple ClickUp workspaces.&#x20;

Here's how to connect to multiple ClickUp workspaces within one Jam team workspace:

1. Go to your account or team settings. Click on "Connected Apps". Then click on "ClickUp". The ClickUp authentication flow will open in a new tab. <br>
2.

```
<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FrApHUh3vbZ1mFxfAxf3G%2Fclickup-team-1.gif?alt=media&#x26;token=574c55c9-4040-4340-908f-def804cb8b7f" alt="" width="375"><figcaption></figcaption></figure></div>
```

3. You can select/deselect the ClickUp workspaces you want to connect to.

   *Note: Make sure to connect with all the workspaces that you'll need because you'll not be able to view this screen again unless you disconnect + reconnect your ClickUp connection with Jam.*<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FcdklVVmB2PRbUvzCzGdv%2Fclickup-team-2.gif?alt=media&#x26;token=bd29fa19-10bd-4b83-b00b-3fe9e5984c75" alt="" width="375"><figcaption></figcaption></figure></div>
4. After you select the workspaces, there will be a blue circle around them to indicate that you selected those workspaces. Click on the 'Connect Workspaces' button.

&#x20;      ![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FguWjyn8ryUoegkSfZp66%2Fimage.png?alt=media\&token=b3a2c6fa-beac-4cea-a288-b29d2fac23a2)

7. After you are done connecting to ClickUp, you will be able to see which ClickUp workspace(s) are connected to that Jam team workspace.&#x20;

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fz1SlanQZRYy25R7yOT56%2Fclickup-team-3.gif?alt=media&#x26;token=2c11bf89-b9c1-4c51-b477-3fbb43bbbfca" alt="" width="375"><figcaption></figcaption></figure></div>

*Note: Due to a ClickUp API limitation, you can only connect ClickUp to one Jam account or team workspace at a time. (Their API will overwrite the previous connection instead of issuing a new auth token for each connection)*

---

# Source: https://jam.dev/docs/guides/tutorials/configure-jam-in-ai-apps.md

# Configure Jam in AI Apps

With Jam you can create a perfect bug report in just one click, automatically capturing detailed logs from your AI app so engineers can pinpoint and resolve issues fast.&#x20;

### Here's how to use Jam for AI apps

#### Jam.Metadata

Use [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") to log parameters such as temperature, max token length, context window size, or any custom settings you need.

**How it helps:**&#x20;

* **Version & configuration consistency:** identify changes that cause unexpected AI behavior, such as modifying temperature settings unintentionally or deploying a beta system prompt. You can easily get version numbers, system prompts, and configuration settings with every bug report.&#x20;

<figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2Fuz2jyu2g4J23YMxph5By%2Fimage.png?alt=media&#x26;token=1dcc65c1-c5e9-45fc-a513-6f56aab67ade" alt=""><figcaption></figcaption></figure>

#### Instant replay

Use [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") to catch nondeterministic bugs, in cases when a model provides incorrect responses, or hallucinations.&#x20;

**How it helps:**&#x20;

* **Context drift:** AI apps sometimes lose track of earlier context, leading to inconsistent or irrelevant outputs. Use instant replay to capture this behavior so engineers can pinpoint when and where the conversation deviates.
* **Error and exception details:** AI app bots can sometimes fail to return a response and instead output a generic error message. With instant replay you can automatically capture a bug that just happened, without having to reproduce it again, and engineers get all technical details they need to debug.&#x20;

*Bonus: with* [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") *you get automatic repro steps, and engineers always get a useful ticket.*&#x20;

<figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FFn43eP5zkUQi1CG1DcEj%2FIR-for-AI.gif?alt=media&#x26;token=29fea20a-cf62-455f-b87c-edfe6928cfe5" alt="" width="563"><figcaption></figcaption></figure>

#### DevTools

Engineers get full stack trace and console logs with [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") so they can quickly identify the cause for specific issues in your AI app.&#x20;

**How it helps:**&#x20;

* **Output variability & latency:** when an AI app returns inconsistent responses, the captured console and network logs can reveal if unexpected API responses or token limits are affecting performance.

<figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2F8nH4PIuKI9aZv1a33WLP%2Fimage.png?alt=media&#x26;token=7d5c7768-f8b5-44b9-9fff-326703cb5330" alt="" width="563"><figcaption></figcaption></figure>

#### Backend logs

Use Jam's [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") integration to automatically capture server-side errors, so engineers can quickly diagnose issues such as rate limiting or misconfigured API endpoints.&#x20;

**How it helps:**&#x20;

* **Backend diagnostics:** when your AI app’s backend encounters issues (like HTTP 503 errors or timeouts during LLM API calls), these errors are logged and attached to the bug report.&#x20;

<figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2F3Xx3rpmQva74H62g3AIc%2Fimage%20(3).png?alt=media&#x26;token=b0597fc4-93fa-42f3-918e-06d017605854" alt="" width="563"><figcaption></figcaption></figure>

#### Screen recording&#x20;

Use [Broken link](https://jam.dev/docs/guides/tutorials/broken-reference "mention") to capture the intermediate step the AI takes while reasoning.&#x20;

**How it helps:**&#x20;

* **Chain-of-thought debugging:** in cases when answers are incorrect or incomplete, by capturing the reasoning state engineers can review the steps taken by the model.

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).&#x20;

---

# Source: https://jam.dev/docs/get-started/creating-a-jam.md

# Creating a Jam

## Overview

Jam helps you capture bugs and issues with full technical context. You can create Jams on desktop using our Chrome extension or on mobile with our iOS app.&#x20;

### Creating a Jam on Desktop

{% embed url="<https://www.youtube.com/watch?v=umdSWiuuoY0>" %}

#### Install the Browser Extension

{% stepper %}
{% step %}
**Download and Install**\
Visit the Chrome Web Store and install the browser extension

<a href="https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci" class="button primary">Install Chrome Extension</a>
{% endstep %}

{% step %}
**Pin the Extension**\
Pin Jam to your browser toolbar for quick access
{% endstep %}

{% step %}
**Create Your Account**\
Enter your email and set up your Jam account
{% endstep %}

{% step %}
**Launch the extension**\
Click the Jam icon in your toolbar and choose your capture method
{% endstep %}
{% endstepper %}

#### Capture Methods

Choose from three capture methods:

{% tabs %}
{% tab title="Screenshot" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJS5v9N397BjapdqyKKCf%2FCapture%20Method_%20Screenshot.png?alt=media&#x26;token=923efc26-7062-46be-9123-d3abc5464832" alt=""><figcaption></figcaption></figure>

Captures the current page state with full technical context.
{% endtab %}

{% tab title="Video Recording" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F12zWW4tgFmIfNIRbtHJd%2FCapture%20Method_%20Screenshot-1.png?alt=media&#x26;token=7da2315f-3fcd-4340-9e19-36883581f2a5" alt=""><figcaption></figcaption></figure>

Records your screen while reproducing the issue step-by-step.
{% endtab %}

{% tab title="Instant Replay" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FTIOlOYMdnlyJk3Y5ttpP%2FCapture%20Method_%20Instant%20Replay.png?alt=media&#x26;token=1ae77372-f3d2-4184-b1f9-724c66995248" alt=""><figcaption></figcaption></figure>

Automatically captures the last 30 seconds of activity. No need to reproduce the bug.
{% endtab %}
{% endtabs %}

#### Create Your First Jam

1. Select your capture method
2. Add a description
3. Click `Create` to generate your first Jam
4. Share your Jam

Your Jam opens automatically in a new tab with all technical details included. The link to your Jam is automatically copied to your clipboard, so you can share it with your team.&#x20;

***

### Creating a Jam on Mobile

{% hint style="info" %}
Jam is currently available for iOS only.
{% endhint %}

{% embed url="<https://www.youtube.com/watch?v=xnENZweQg9Y>" %}

#### Install the Browser Extension

{% stepper %}
{% step %}
**Install the iOS App**\
[Download](https://apps.apple.com/de/app/jam-fix-bugs-faster/id6469037234?l=en-GB) Jam from the App Store or scan the QR code below:<br>

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FSQhU75M3j09SDi2x1sUJ%2Fimage.png?alt=media&#x26;token=03c9a67d-9dc4-4b91-9f99-39824f6a6636" alt="" width="125"><figcaption><p>Scan to download</p></figcaption></figure></div>
{% endstep %}

{% step %}
**Start Recording**\
Tap the Jam button and begin screen broadcast to start capturing
{% endstep %}

{% step %}
**Record the issue**\
Navigate to your app or website to demonstrate the issue
{% endstep %}

{% step %}
**Stop Recording and Send**\
Stop the broadcast, trim your video, add a description, and send to your issue tracker.
{% endstep %}
{% endstepper %}

---

# Source: https://jam.dev/docs/get-started/creating-a-recording-link.md

# Creating a Recording Link

### Create Your First Recording Link

{% embed url="<https://www.youtube.com/watch?t=1s&v=GP0SBqWU-58>" %}

{% stepper %}
{% step %}
**Create Your Account**\
Enter your email and set up your Jam account.

<a href="https://jam.dev/login" class="button primary">Sign up for free</a>
{% endstep %}

{% step %}
**Navigate to recording links**\
Pin Jam to your browser toolbar for quick access during testing and debugging.
{% endstep %}

{% step %}
**Send your recording Link**\
They click the link and reproduce the issue. Jam automatically captures all technical details
{% endstep %}
{% endstepper %}

### Adding a reference

When you create a recording link, you can associate the recording link with what you’re working on: a ticket in an issue tracker, an email address, or a web page.

1. Copy the link to your issue tracker ticket:

   <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FHPDeeCwEbKTg9oJnhgy8%2FScreenshot%202025-09-05%20at%2012.20.18%E2%80%AFPM.png?alt=media&#x26;token=7c9dee3c-b071-434c-935e-964302094eeb" alt=""><figcaption></figcaption></figure>
2. Create a recording link. In the “reference name or link”, paste your link. You'll see that we identify your issue tracker and ticket number:<br>

   <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F8NYTMzz7sK5LhS9geLyK%2FScreenshot%202025-09-05%20at%2012.22.46%E2%80%AFPM.png?alt=media&#x26;token=de3b1fa8-51ec-4956-90ed-9e9aa77cc5c0" alt=""><figcaption><p>You can also enter any web URL or email address!</p></figcaption></figure>
3. Send your recording link to your customer.
4. When your customer records a Jam, we’ll link the Jam back to your ticket:

   <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6NH2xSfwJiuWXmmkSSz6%2FScreenshot%202025-09-05%20at%2012.27.32%E2%80%AFPM.png?alt=media&#x26;token=f2e63a89-cbdc-472c-bbec-400df4dd1cd7" alt=""><figcaption></figcaption></figure>

### Recording Links with Console Logs

Recording links can capture console and network logs from anyone who uses them. No more debugging calls - just send the link and get the context you need.

See our [Quickstart guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs) for step-by-step instructions on setting up recording links with console logs and network requests.

***

---

# Source: https://jam.dev/docs/guides/tutorials/deploy-jam-org-wide.md

# Deploy Jam Org-Wide

Enterprise admins can give team members instant access to Jam — no setup required.&#x20;

With Google Admin Console you can automatically install the Jam extension for everyone in your organization.&#x20;

In just a few seconds you can guarantee pain-free & efficient deployment, setting up your company to deliver quality software faster than ever before.

#### How to set up Jam in Google Admin Console

{% hint style="info" %}
Prerequisite: make sure you have Google Workspace Admin Access
{% endhint %}

1. Navigate to **admin.google.com** and log in with admin credentials.
2. Go to **Devices > Chrome > Apps & extensions >** **Users & Browsers**&#x20;
3. Click **+ Add > Add from Chrome Web Store**.
4. Search for **jam.dev** and select it.<br>

   <figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2Fd2hpB5tGt4Cvt207OVNY%2Fimage.png?alt=media&#x26;token=fc712f23-c5b8-4153-80d8-0e3de0288fec" alt="" width="563"><figcaption></figcaption></figure>
5. Set the installation policy to **Force Install** or **Force install + pin to browser toolbar** to make it easier for all employees to find Jam.
6. Click **Save** to apply settings.

Employees in your organization will see the Jam extension automatically installed the next time they launch Chrome.

---

# Source: https://jam.dev/docs/record-a-jam/video-screen-recording/desktop-recording.md

# Desktop Recording

With Jam, you can record a single tab, an entire window, or your full desktop.&#x20;

When recording a window or your entire desktop, Jam captures console logs and network requests from every tab you interact with during the recording (as long as Jam is installed in that browser window).&#x20;

That means, if you're trying to demonstrate a bug that spans across multiple tabs or windows (like something updating in one place but not in another), Jam can record that in real-time. It simultaneously captures console logs and network requests from both tabs, giving engineers a holistic view of the bug even if it's not contained within a single tab.

That way engineers can track a bug through multiple sites, tabs and windows.

See steps here to enable Jam on incognito windows:

{% content-ref url="../incognito-sessions" %}
[incognito-sessions](https://jam.dev/docs/record-a-jam/incognito-sessions)
{% endcontent-ref %}

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

Step 1: Open your "System Preferences".

Step 2: Open your "Security & Privacy" settings.

Step 3: Click on the "Privacy" tab.

<figure><img src="https://jam.dev/docs/content/images/2023/03/Screen-Shot-2023-03-30-at-9.05.13-PM.png" alt=""><figcaption></figcaption></figure>

Step 4: Select "Screen Recording" from the list.

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FN8j1zBucNGP2kgSHdG6d%2Fimage.png?alt=media\&token=ae109a07-109d-41ef-8609-1554234d1176)

Step 5: If you don't see "Google Chrome" on the list, skip to Step 6. If you see "Google Chrome" on the list, carefully follow the next steps. Remove "Google Chrome" completely from the list. It's important that you completely remove it (not just uncheck the box next to "Google Chrome") using the minus icon.

Step 6: Add "Google Chrome" to the list by using the plus icon.

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FC3MWmvDAiL11Npb46aH9%2Fimage.png?alt=media\&token=1611bfa1-0f7f-46af-9e5c-45d1b1185c20)

---

# Source: https://jam.dev/docs/debug-a-jam/devtools.md

# DevTools

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FoOIz3cIMwGy61fgsrpaN%2Fnetwork.gif?alt=media&#x26;token=b5350984-eade-439d-8577-de5cb9053523" alt=""><figcaption></figcaption></figure>

### Overview

Every Jam capture automatically includes comprehensive 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.<br>

### Core Features

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Visual Context</strong></td><td>Screenshots and screen recordings with annotation tools</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F2C8XJjmnhphIRSuLo104%2FVisual%20Context.png?alt=media&#x26;token=4d565926-49c1-4d51-b56a-2fe756a4ab12">Visual Context.png</a></td><td></td></tr><tr><td><strong>Metadata</strong> <code>Customizable</code></td><td>URL, timestamp, device info, browser version, OS, and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FW0QFlGjEJjFqF7AwmrV0%2FDevice%20Info.png?alt=media&#x26;token=d5842034-5dbf-4204-8c12-888eabf5beba">Device Info.png</a></td><td><a href="devtools/jam.metadata">jam.metadata</a></td></tr><tr><td><strong>Developer Logs</strong></td><td>Console logs and complete network request details and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjSSvP2nbPkxa8KeEu2Rh%2FDev%20Logs.png?alt=media&#x26;token=87e2d9c9-b8c1-4956-a60a-865903bd52a4">Dev Logs.png</a></td><td><a href="devtools">devtools</a></td></tr><tr><td><strong>User Events</strong></td><td>User clicks, navigation events and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FlNN7M1tQm5XPUeZUfyUo%2FUser%20Events.png?alt=media&#x26;token=31e6ffa4-c7f0-4d4d-8654-4ba3e6605873">User Events.png</a></td><td></td></tr></tbody></table>

#### Customization

#### **Layouts**

Switch between side and bottom layout to fit your workflow. The DevTools panel adapts to your preferred layout.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FoOIz3cIMwGy61fgsrpaN%2Fnetwork.gif?alt=media&#x26;token=b5350984-eade-439d-8577-de5cb9053523" alt=""><figcaption></figcaption></figure>

{% tabs %}
{% tab title="Side Dock" %}
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.
{% endtab %}

{% tab title="Bottom Dock" %}
DevTools expand across the bottom for detailed network analysis. Perfect for inspecting multiple requests or long console outputs.
{% endtab %}
{% endtabs %}

#### Keyboard Shortcuts

Use familiar Chrome DevTools shortcuts for faster navigation:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F2bHsEGGVfdDLWiodMfST%2FJam%20Shortcuts.gif?alt=media&#x26;token=0bf034b2-2a08-4443-ab3f-a1fc8133c010" alt=""><figcaption></figcaption></figure>

| Action                            | Shortcut                                       |
| --------------------------------- | ---------------------------------------------- |
| Change layout                     | <kbd>⌘</kbd> + <kbd>Shift</kbd> + <kbd>D</kbd> |
| Navigate through network requests | <kbd>↑↓</kbd>                                  |
| Open network request details      | <kbd>⏎</kbd> Return                            |
| Close network request details     | <kbd>Esc</kbd>                                 |

<br>

### FAQs

<details>

<summary>Do I need to enable DevTools manually?</summary>

No. DevTools data is automatically captured with every Jam. No setup or configuration required. You can capture additional meta data with [jam.metadata](https://jam.dev/docs/debug-a-jam/devtools/jam.metadata "mention").

</details>

<details>

<summary>Can I filter console logs by severity?</summary>

Yes. Use the severity filter to show only errors, warnings, or specific log levels that matter for debugging.

</details>

<details>

<summary>How detailed is the network timing data?</summary>

You get complete timing breakdowns including DNS lookup, connection time, and response duration – just like Chrome DevTools.

</details>

---

# Source: https://jam.dev/docs/record-a-jam/jam-for-ios/enabling-taps-and-gestures-on-ios-screen-recording.md

# Enabling Taps and Gestures on iOS Screen Recording

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

### **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").

---

# Source: https://jam.dev/docs/integrations/figma.md

# Figma

{% embed url="<https://youtu.be/n0QRUzosm2c>" %}

You can paste Figma links into Jam – and engineers will see the Figma frame side by side your initial bug report.

That means they don't have to open a new tab to see what's in Figma, and they don't have to search around your Figma file. It's right there for them!

## How to embed Figma files in Jams

1. Capture a visual bug on the screen using Jam
2. In the Jam description, paste in a Figma link
3. Click "Create" to create your Jam
4. Open the Jam you just created. You'll see a Figma icon at the bottom of the Jam – click on it, and a perfect Figma embed will appear.&#x20;

That way, engineers don't need to open another tab to see what the intended designs should be. It's right there – in the Jam – embedded perfectly from the Figma.

---

# Source: https://jam.dev/docs/integrations/fin-ai.md

# Fin AI

[intercom-fin-ai](https://jam.dev/docs/jam-for-customer-support/intercom-fin-ai "mention")

---

# Source: https://jam.dev/docs/integrations/freshdesk.md

# Source: https://jam.dev/docs/jam-for-customer-support/freshdesk.md

# Freshdesk

1. Create a new Recording Link from the Jam browser extension
2. Copy & Paste the customer conversation URL in the Recording Link description (e.g. <https://yourcompany.freshdesk.com/agent/tickets/125324>
3. Share the Recording Link in the customer conversation
4. When the recording is ready, you will receive an email with the customer recording with a reference to the corresponding customer conversation

{% hint style="info" %}
If you want to capture logs and network requests from your Recording Links, follow this [set up guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs).
{% endhint %}

---

# Source: https://jam.dev/docs/record-a-jam/screenshot/full-screen-screenshot.md

# Full screen screenshot

Here's how to take a full screen screenshot with Jam:

1. Choose the screenshot tool in Jam
2. Instead of dragging the cursor to choose an area, click once on the page to capture the full page screenshot

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FTclTYwQrPgQXnG9Wy0M6%2Ffullscreenshot.gif?alt=media&#x26;token=51323fc6-45ba-4849-953e-82f6bf701373" alt=""><figcaption></figcaption></figure>

---

# Source: https://jam.dev/docs/integrations/fullstory.md

# Fullstory

If your website is using Fullstory for customer behavior & analytics, your Jams will automatically include Fullstory session link.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FqbrpKMfPaiwcd36tYDoG%2F8127594a-89d4-4106-b206-3b582897a124_2400x1350.jpg?alt=media&#x26;token=30c0851a-c129-433a-b060-bf97a273bab3" alt=""><figcaption></figcaption></figure>

You'll find the links to the Fullstory session in the info panel in Jam logs.&#x20;

You don't have to connect anything to get started, or write a single line of code. It's just going to be there for your devs every time you report a bug with Jam.&#x20;

---

# Source: https://jam.dev/docs/get-started/getting-started.md

# Getting started

### Overview

Jam helps customer support, product and engineering teams capture and debug issues faster by capturing automatic technical context. Join 200K+ users who capture, feedback, issues and bugs with all developer details included.

### How to Create Jams

Jams can be created in two ways:&#x20;

<table data-card-size="large" data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Request a Jam from anyone</strong></td><td>Getting recordings from users, customers, or team members</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1yY4Rglvb8ewltE10T6n%2FHeader%201200x630.png?alt=media&#x26;token=346f95d4-6a37-4331-a60a-a4bb1ebb07b9">Header 1200x630.png</a></td><td><a href="creating-a-recording-link">creating-a-recording-link</a></td></tr><tr><td><strong>Record a Jam yourself</strong></td><td>Directly capture issues while working via Jam's Chrome extension or iOS app</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FIfQ6bqCm6FQK5eXhJKZ9%2FRecord%20Jam.png?alt=media&#x26;token=604a0914-f342-45dc-88cf-9c2e84442dab">Record Jam.png</a></td><td><a href="creating-a-jam">creating-a-jam</a></td></tr></tbody></table>

| Use Case                      | Best for                                                  | When to use                                                                                      |
| ----------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Request a Jam from anyone** | Getting recordings from users, customers, or team members | Customer bug reports, a-sync user feedback, or remote debugging with team members.               |
| **Record a Jam yourself**     | Direct issue capture while working                        | Testing your own product, documenting bugs during development, or capturing issues in real-time. |

### What's Captured Automatically

Every Jam captures essential debugging information without manual effort:&#x20;

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Visual Context</strong></td><td>Screenshots and screen recordings with annotation tools</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F2C8XJjmnhphIRSuLo104%2FVisual%20Context.png?alt=media&#x26;token=4d565926-49c1-4d51-b56a-2fe756a4ab12">Visual Context.png</a></td><td></td></tr><tr><td><strong>Metadata</strong> <code>Customizable</code></td><td>URL, timestamp, device info, browser version, OS, and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FW0QFlGjEJjFqF7AwmrV0%2FDevice%20Info.png?alt=media&#x26;token=d5842034-5dbf-4204-8c12-888eabf5beba">Device Info.png</a></td><td><a href="../debug-a-jam/devtools/jam.metadata">jam.metadata</a></td></tr><tr><td><strong>Developer Logs</strong></td><td>Console logs and complete network request details and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjSSvP2nbPkxa8KeEu2Rh%2FDev%20Logs.png?alt=media&#x26;token=87e2d9c9-b8c1-4956-a60a-865903bd52a4">Dev Logs.png</a></td><td><a href="../debug-a-jam/devtools">devtools</a></td></tr><tr><td><strong>User Events</strong></td><td>User clicks, navigation events and more</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FlNN7M1tQm5XPUeZUfyUo%2FUser%20Events.png?alt=media&#x26;token=31e6ffa4-c7f0-4d4d-8654-4ba3e6605873">User Events.png</a></td><td></td></tr></tbody></table>

Both recording links and capturing a Jam via our Chrome extension give you the same comprehensive technical context in one easy to share Jam link.&#x20;

#### Customization

1. **Custom Metadata:** Extend what Jam captures with one function call via [jam.metadata](https://jam.dev/docs/debug-a-jam/devtools/jam.metadata "mention")
2. **Sentry Integration:** Connect [sentry](https://jam.dev/docs/integrations/sentry "mention") to see your backend logs directly in Jam.
3. **Recording Links with Console Logs:** Recording links can capture console and network logs from anyone who uses them. [recording-links](https://jam.dev/docs/jam-for-customer-support/recording-links "mention")

***

---

# Source: https://jam.dev/docs/integrations/github.md

# GitHub

{% embed url="<https://www.youtube.com/watch?v=p49JKbY9NUU>" %}

You can connect GitHub and Jam in order to instantly create GitHub issues right from Jam's browser extension. Every GitHub issue you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant GitHub Issues fields right from Jam – like repository, assignees, labels and more. Our goal is to make you 20x faster at logging bugs to GitHub Issues.

## How to use Jam + GitHub

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20;     [getting-started](https://jam.dev/docs/get-started/getting-started "mention")

2. Next, capture your bug with Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1NhyFtpvKZ3y0jZBO7FD%2Fgithub-1.gif?alt=media&#x26;token=db9ef072-3afc-456e-90ea-5b619c222739" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to GitHub.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FdRmvTDrq58kuuPVKjhge%2Fgithub-2.gif?alt=media&#x26;token=c259aaca-4958-4e6f-a2db-96b7e0463528" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with GitHub.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBZT5wOknOGUd28oFZh1n%2Fgithub-5.gif?alt=media&#x26;token=e7fc94c0-dc17-46a7-94f5-49ac9c144ada" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to GitHub, you will be able to setup your GitHub issue right from Jam. Choose the repository, assignees, labels, milestone, etc., right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F9nDzlgwIH7PsfnSS9FBO%2Fgithub-4.gif?alt=media&#x26;token=85ee584e-721a-4216-88d1-bb8124d8c8e9" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields"  to manage which fields from GitHub are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvQies3kbl9JYELpBCdJs%2Fgithub-edit.gif?alt=media&#x26;token=b88746cc-0e18-4078-b1e6-b834d14c02ca" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create issue" and once Jam creates your GitHub issue, it will automatically open in a new tab. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FKLSl1p9q8LAhmZXZdYFL%2Fgithub-6.gif?alt=media&#x26;token=48d33aeb-3088-462f-8cbc-8b0948adc83d" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to GitHub

You can automatically create GitHub issues from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a GitHub issue.
2. Click "Send to App" and select GitHub.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBydB3kR5YHU9bee8Dn0l%2Fgithub-tools-1.gif?alt=media&#x26;token=e4c53f8b-8454-4d78-97ab-c39786dd9ba7" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + GitHub before, it will first redirect you to log in with GitHub.
4. Enter the details of your GitHub issue: repository, assignees, labels, milestone, etc. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJwOWUY9DzbMVv0DnKMwG%2Fgithub-tools-2.gif?alt=media&#x26;token=f8dbc7c4-bb3c-4fdc-b1b5-0ba7c25c05ee" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields"  to manage which fields from GitHub are shown in Jam.
6. Click "Create issue" to create your GitHub issue.&#x20;

---

# Source: https://jam.dev/docs/integrations/gitlab.md

# GitLab

You can connect GitLab and Jam in order to instantly create GitLab issues right from Jam's browser extension. Every GitLab issue you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant GitLab Issues fields right from Jam – like repository, assignees, labels and more. Our goal is to make you 20x faster at logging bugs to GitLab Issues.

## How to use Jam + GitLab

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20;       [Get Started](https://jam.dev/docs/get-started)

2. Next, capture your bug with Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FR8wiXyYTLuDAfYWwxH9W%2Fgitlab-1.gif?alt=media&#x26;token=40208849-6dee-4010-8c0d-620981665671" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to GitLab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fx0ICYUTSzsYWLBnX96DU%2Fgitlab-2.gif?alt=media&#x26;token=0bcf01de-afdf-4378-a3a6-96b6b64103a1" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with GitLab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FQV3PaZVwArQh1caAC1D6%2Fgitlab-3.gif?alt=media&#x26;token=ebd9e295-5d85-4f71-b006-8f26c5a3dd54" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to GitLab, you will be able to setup your GitLab issue right from Jam. Choose the Project, Assignee, Labels, Due Date, Milestones, etc., right from Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fr2neRIiWnSUIFeEC57tG%2Fgitlab-4.gif?alt=media&#x26;token=66d47de5-060d-41ae-9897-d92ec8b63bc5" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields" to manage which fields from GitLab are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fj6YQXfFwyBaCvHP4hoH8%2Fgitlab-5.gif?alt=media&#x26;token=e7473171-f972-403e-b33d-d9d28e6fe73d" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create issue" and once Jam creates your GitLab issue, it will automatically open in a new tab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FzFgUedoI4ubEo59wlujh%2Fgitlab-6.gif?alt=media&#x26;token=791a6295-acd9-4228-9f2a-5a85b5ffbb2e" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to GitLab

You can automatically create GitLab issues from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a GitLab issue.
2. Click "Send to App" and select GitLab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJs9tgCTCOMKAiXTYOybt%2Fgitlab-7.gif?alt=media&#x26;token=1fead67b-6907-4b82-a05b-9b964848087e" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + GitLab before, it will first redirect you to log in with Gitlab.
4. Enter the details of your GitLab issue: repository, assignees, labels, milestone, etc. \ <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fl78vBuVxyXXxJkPEkP6G%2Fgitlab-8.gif?alt=media&#x26;token=b9f1bc7a-3834-4f9a-a034-9e3556809b13" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields"  to manage which fields from GitLab are shown in Jam.
6. Click "Create issue" to create your GitLab issue.&#x20;

---

# Source: https://jam.dev/docs/debug-a-jam/devtools/graphql.md

# GraphQL

One major difference between GraphQL and REST APIs is how they handle errors. In a REST API, different HTTP status codes indicate the outcome of a request. For example, a 200 status code means the request was successful, while a 400 status code means there was a client error.

In contrast, GraphQL always returns a 200 status code, even if there are errors in the response body. The [GraphQL spec](https://spec.graphql.org/October2021/?ref=strawberryjam.ghost.io#sec-Errors) suggests that servers respond with a structured errors field. This makes errors machine-readable but drops the semantic meaning of HTTP status codes. Additionally, GraphQL typically uses a single endpoint (`/graphql`) for all operations, making it difficult to distinguish between different requests when debugging.

This means that to effectively debug GraphQL, you typically have to comb through every single request to identify errors.

### GraphQL Debug Tools

We addresses these challenges with specialized debugging features:

**Automatic Error Detection** - Jam automatically flags GraphQL responses that contain errors in the response body, even though they return HTTP 200 status codes.

**Mutation Name Visibility** - Jam auto-detects and shows the GraphQL operation name directly in the dev tools interface, making it easy to identify specific mutations and queries without clicking into each request.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F8tFkHTPUoS1JRFhEWFKQ%2FGraphQL-devtools.gif?alt=media&#x26;token=5275877e-23cd-4f2c-b1ee-1062c75cf604" alt=""><figcaption></figcaption></figure>

These features eliminate the need to manually inspect every GraphQL request, speeding up your debugging workflow.

---

# Source: https://jam.dev/docs/jam-for-customer-support/recording-links/how-to-use-recording-links.md

# How to Use Recording Links

## Creating a Recording Link

#### From the Browser Extension

1. Click on the Jam strawberry to open the extension.\
   ![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fgkz0LkaFa2qqrY71hxZ2%2Fimage.png?alt=media\&token=2aa6b641-1c0a-49e9-9e58-ee1d6ae9692a)
2. Click "Create Link".\
   &#x20;![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvLe56v4bCFDd7ydTfUrw%2Fimage.png?alt=media\&token=96715768-7e08-4f81-9e1f-330eac6beedd)
3. Optionally name your link or paste the URL of your customer conversation (from Zendesk, Hubspot, Jira, etc.).
4. Select "Reusable" if you want to enable multiple recordings from the same link.
5. Click "Create link", the link will be automatically copied to your clipboard, ready for sharing!

#### From the Jam Dashboard

1. Go to [jam.dev/s/recording-links](https://jam.dev/s/recording-links)
2. Click "+ New".
3. A pop-up appears, click "Create Link".
4. Optionally name your link or paste the URL of your customer conversation (for example, Zendesk, Hubspot, Jira).
5. The link will be automatically copied to your clipboard, ready for sharing!

## Sharing Recording Links

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

## What Recipients Experience

{% hint style="info" %}
The experience is designed to be accessible to anyone, regardless of their technical background.
{% endhint %}

When someone clicks your recording link:

1. **Instant access** - Opens directly in their browser, no downloads
2. **Simple interface** - Big "Start Recording" button, clear instructions
3. **One-click recording** - Captures their screen, showing the bug
4. **Submit Recording** - Recording uploads and notifies you immediately

## Viewing Recording Links Jams

Recordings from recording links appear in your Jam dashboard as regular Jams:

1. You'll receive an email notification when a Jam from your recording link is submitted
2. Find the recording in your team's Jam dashboard
3. All your integrations work normally - recordings route to Jira, Linear, etc.

## Reusable recording links

Recording links are reusable by default. Reusable recording links are perfect for ongoing customer support or QA workflows, feedback buttons, email signatures, pinned Slack messages, and more!

#### Setting the title of the Jam

You can choose the title of the Jam that is created from your link by adding `jam-title` to the query string.&#x20;

For example, if you want the title of the Jam to be "Shopping cart bug": `https://recorder.jam.dev/QrBnf3s?jam-title=Shopping+cart+bug`&#x20;

Or if it was for a same-domain Recording URL:\
`https://www.your.com/?jam-id=QrBnf3s&jam-title=Shopping+cart+bug`&#x20;

#### Setting other Jam parameters:

You can also use your Recording Link's URL querystring to adjust or override other Recording Links settings:

* `jam-folder=<FOLDER_ID>` — the folder to route the recorded Jam into. Use the 4-character *ID*, not the *name*—on a folder page, the URL looks like: `https://jam.dev/s/<TEAM-ID>/<FOLDER-ID>`
* `jam-reference=<URL_OR_EMAIL>` — a user identifier, or URL (e.g. to an issue tracker, helpdesk conversation, etc)

This is a great use case for when you want to customize link behavior with macros, text expanders, or custom link generators you build for your team.

## Send Recording Links from your own domain and collect console logs

{% content-ref url="../send-recording-links-from-your-own-domain-and-collect-console-logs" %}
[send-recording-links-from-your-own-domain-and-collect-console-logs](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs)
{% endcontent-ref %}

## Pro Tips

**Single-use recording links**: Recording links are reusable by default. If you prefer, you can create links that expire after a single use.

**Add a URL to your customer conversation** when you create a recording link, so you will always have know the context when a new recording comes in.

**Universal compatibility**: Recording Links are compatible with the desktop versions of Chrome, Edge, Firefox, and Safari.&#x20;

---

# Source: https://jam.dev/docs/integrations/hubspot.md

# Source: https://jam.dev/docs/jam-for-customer-support/hubspot.md

# Hubspot

1. Create a new Recording Link from the Jam browser extension
2. Copy & Paste the customer conversation URL in the Recording Link description (e.g. <https://yourcompany.hubspot.com/agent/tickets/125324>
3. Share the Recording Link in the customer conversation
4. When the recording is ready, you will receive an email with the customer recording with a reference to the corresponding customer conversation

{% hint style="info" %}
If you want to capture logs and network requests from your Recording Links, follow this [set up guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs).
{% endhint %}

---

# Source: https://jam.dev/docs/record-a-jam/instant-replay/iframe-and-canvas-support.md

# iFrame & canvas support

Instant Replay is designed to keep website performance fast and lightweight, while still capturing bugs on the go, which means that Instant Replay ignores the heaviest HTML elements: iframe & canvas.&#x20;

That means if you capture an Instant Replay of a bug on a page that has iframe or canvas elements, you’ll see a black box in the resulting Instant Replay where those elements are.

Internally at Jam, we’ve gone back and forth on what is the best way to handle these heavier HTML elements, and what we’ve found time and time again is that our users prefer not to have them captured, than to have a more laggy experience. Having said that, we’re open to feedback and curious what you think. If you’d like to share any feedback, please reach out to us at <hello@jam.dev>.

---

# Source: https://jam.dev/docs/record-a-jam/incognito-sessions.md

# Incognito Sessions

### Overview

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.

### Key Benefits

**Full feature access:** All Jam tools work in private browsing mode\
**Complete bug context:** Capture instant replay, network logs, console data, and device info\
**Privacy-first testing:** Test and debug without affecting your main browser session\
**Clean environment:** Isolate testing from extensions, cookies, and cached data

### How It Works

When enabled for incognito mode, Jam provides the same comprehensive debugging toolkit you get in regular browsing:

* **Instant replay** captures the last 30 seconds of user actions
* **Screen recording** documents the full bug reproduction
* **Network logs** show API calls, failed requests, and performance data
* **Console logs** capture JavaScript errors and warnings
* **Device information** includes browser, OS, and viewport details

### Getting Started

{% tabs %}
{% tab title="Chrome" %}
![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FPOddjUP3LyAG1j72QTfO%2Fa91f85b5-124d-4374-8da5-f53095acdc1b_796x540.gif?alt=media\&token=e0e2c080-ed0f-4bfe-93a5-b5eb20a8684b)\
\
**Enable Incognito Access in Chrome**

1. Go to [chrome://extensions](chrome://extensions/) in your address bar
2. Find the Jam extension
3. Click Details
4. Toggle on Allow in incognito

You should now see the Jam extension icon in incognito windows.
{% endtab %}

{% tab title="Firefox" %}
**Enable Incognito Access in Firefox**

1. Go to <about:addons> in your address bar
2. Find the Jam extension
3. Click on the extension name
4. Under Run in Private Windows, select Allow

You should now see the Jam extension icon in private windows.
{% endtab %}

{% 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

You should now see the Jam extension icon in InPrivate windows.
{% endtab %}
{% endtabs %}

### FAQs

<details>

<summary>Does incognito mode affect the quality of bug reports?</summary>

No. You get the same comprehensive data collection in incognito mode, including full network logs, console output, and device information.

</details>

<details>

<summary>Can I use Jam in incognito mode without enabling this setting?</summary>

No. Browser security policies require explicit permission for extensions to run in private browsing modes.

</details>

<details>

<summary>Will my incognito browsing data be saved in Jam reports?</summary>

Jam only captures the specific page and interactions you choose to record. Your broader incognito browsing session remains private.

</details>

---

# Source: https://jam.dev/docs/record-a-jam/instant-replay.md

# Instant Replay

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FZDFlIjSNIg59J2kzOtU6%2Finstantreplay.gif?alt=media&#x26;token=bcc33065-eb09-4746-8f36-eed62d2fcc81" alt=""><figcaption></figcaption></figure>

### Overview

Instant Replay captures bugs the moment they happen, with complete technical context, and packages everything into a shareable link. No need to stop your workflow or recreate issues. In just two clicks you'll be able to send engineers everything they need to debug.<br>

### Key Benefits

* **Complete technical context:** Automatically captures DOM replay, console logs, network requests, and device information
* **Zero workflow disruption:** Capture bugs instantly without stopping to recreate or re-record
* **Engineer-ready format:** All diagnostics packaged into one shareable link for tickets or direct communication
* **Privacy controls:** Crop video content before sharing to protect sensitive information<br>

### How It Works

When you create an Instant Replay, Jam automatically captures and includes:

* **Up to 2 minutes** of DOM session replay
* **Console logs** with errors and warnings
* **Network requests** with full inspection capabilities
* **Environment details:** URL, timestamp, country, device, OS, browser
* **Technical specs:** Viewport size and network speed

Everything gets packaged into a single link that integrates seamlessly with your existing bug tracking workflow.

#### Capture Behavior

{% hint style="info" %}
Instant Replay captures up to 2 minutes of session activity. For newly opened tabs or data-heavy websites, the capture duration may be shorter.
{% endhint %}

#### Privacy Controls

Before sharing your Instant Replay, you can crop the video to remove any sections you don't want to include. This gives you complete control over what technical context gets shared with your team.

#### Technical Limitations

<table><thead><tr><th>Scenario</th><th>Capture Duration</th><th data-hidden></th></tr></thead><tbody><tr><td>Standard browsing</td><td>Up to 2 minutes</td><td></td></tr><tr><td>Newly opened tabs</td><td>May be less than 2 minutes</td><td></td></tr><tr><td>Data-heavy websites</td><td>May be less than 2 minutes</td><td></td></tr></tbody></table>

<details>

<summary>How far back can Instant Replay capture?</summary>

Up to 2 minutes of session activity, though this may be shorter for newly opened tabs or websites with heavy data loads.

</details>

<details>

<summary>Can I control what gets shared in my Instant Replay?</summary>

Yes. You can crop the video portion of your Instant Replay before sharing to remove any content you don't want included.

</details>

<details>

<summary>What technical information is automatically included?</summary>

Every Instant Replay includes DOM session replay, console logs, network requests, URL, timestamp, device information, browser details, and viewport size.

</details>

---

# Source: https://jam.dev/docs/jam-for-customer-support/intercom-fin-ai.md

# Intercom Fin AI

### Requirements

✅ This is a feature for paid plans\
✅ [Jam Intercom App](https://www.intercom.com/app-store/?app_package_code=jam-recorder) 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](https://www.intercom.com/app-store/?app_package_code=jam-recorder) directly to your Fin workflows, allowing you to prompt users for screen recordings at specific points in your customer support process. For example, you could place Jam before Fin starts to gather context, or before handing off the conversation to a human agent.

### 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. This can be done with a simple drop-in app step for quick setup, or combined with webhooks if you need more control and want Intercom to branch the workflow depending on whether the customer recorded or opted out.

#### Step 1: Access Your Fin Workflow

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

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FLqQlXmbxYFhsBcdZ7m3j%2FScreen%20Cast%202025-06-10%20at%2011.23.55%20AM.gif?alt=media&#x26;token=c4de56d5-04dd-43fb-8a68-104b0ff5d922" alt=""><figcaption></figcaption></figure>

#### Step 2: Set Channel to Web

Ensure your workflow channel is set to "Web".&#x20;

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvMBOT8eXcwg3TeWBLs4Q%2FScreenshot%202025-06-10%20at%2011.23.06.png?alt=media&#x26;token=821db5fe-98f2-4b53-bef8-a71e8331ad11" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Jam for Intercom currently doesn't support mobile devices. Make sure to set your workflow channel to Web, otherwise Jam will not work as expected.
{% endhint %}

#### Step 3: Add Jam Step

At any point in your Fin workflow, you can add a new step:

1. Click "**Add step**"
2. Select "**Send an app**"
3. Choose "Jam" from the list of available apps
4. When adding the Jam step, you’ll need to **configure** some fields:

* **Message**:t his is the standard message that will accompany every Jam link. Consider how you want to introduce this request to your end customer so that they understand the purpose of recording their screen with Jam.
* **Opt out**: Check Yes or No. Clicking Yes will provide your end customer with two paths to move forward: one will be to record a Jam. The other will be to provide more issue detail by typing their response. Jam provides two options to ensure your end customers can pursue a solution through their preferred method of communication. If you prefer that end customers only have the option to record a Jam, select No.

{% hint style="info" %}
ℹ️ *Only select **Yes** if you plan to configure Jam with webhooks — otherwise, this setting will have no impact.*
{% endhint %}

1. Click "**Request screen recording**" to add the app to the workflow

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FzHQThcQOK4Z444eCQNrb%2FScreen%20Cast%202025-09-12%20at%2010.30.15%20AM.gif?alt=media&#x26;token=d9b9015d-ebe8-4384-8df9-3635ecae136d" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
If you don't see Jam in the available apps list, please go back to [Jam for Customer support documentation ](https://jam.dev/docs/jam-for-customer-support/broken-reference)install Jam in your Intercom workspace.
{% endhint %}

### (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](https://jam.dev/docs/integrations/webhooks).

#### **1. Add Wait for Webhook**

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

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FRNUXJ5INLRfcLe2K254b%2FScreenshot%202025-09-12%20at%2010.14.04.png?alt=media&#x26;token=5f0bcd49-e22c-4f3f-9141-c255f9ea9edb" alt=""><figcaption></figcaption></figure>

* In the resulting menu that opens, you should see an Example Request.
* Edit the example text in the following:
  * `“example_key”` -> `“event”`
  * `“example value (please edit)”` -> `“intercom.recorder.opted_out”`
  * add `"payload"` inside `"data"` with an empty curly brackets `{}`

Here's is the full example request if you want to just copy/paste:

```
{
  "event": "some string",
  "payload": {}
}
```

* Next, provide a title for your webhook for easier reference later on. You can edit it by clicking into the bolded text in the view you’re currently in. It should be directly to the left of the Save and Close button.&#x20;
* Lastly, copy the Webhook URL. Copy everything except for the ending characters: “/\<Conversation ID>”.&#x20;

Click Save and Close. Note: your view should look like the below screenshot.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FdH1SMrzhPEtmQLo9xguz%2FScreenshot%202025-09-29%20at%2019.11.10.png?alt=media&#x26;token=189aa53e-ba8b-451e-83f2-67cd5c7acf97" alt=""><figcaption></figcaption></figure>

{% hint style="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.
{% endhint %}

#### **2. Register the Webhook in Jam**

* Once you have the Webhook URL, you’ll need to register it in Jam so the events can flow correctly.
* Follow the instructions in the[ Jam Webhooks documentation](https://jam.dev/docs/integrations/webhooks#id-2.-using-connectors) to configure your endpoint and paste this URL into the **Endpoint URL** field.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FtHHbwzFTWlrVbdE295kM%2FScreenshot%202025-09-12%20at%2010.18.52.png?alt=media&#x26;token=e4497fc8-7c6d-49c2-9f5f-cbf156dfe2ce" alt=""><figcaption></figcaption></figure>

#### **3. Add Branching Logic**

Return to Intercom. At this point, we are ready to tell the workflow what next step should be taken based on the choice your end customer makes (either they Recorded a Jam, or opted to explain via text).

* Under the Wait for Webhook step you added, click Add Step.
* Type Branches and select the resulting option as shown below.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FeqJeB8ZGEbi9HrP7Y7tr%2FScreenshot%202025-09-12%20at%2010.17.50.png?alt=media&#x26;token=a23ad268-5d8f-4142-acfc-abcea54b5de9" alt=""><figcaption></figcaption></figure>

* Under Branches, we will create two branches.
* Click on the **Missing Condition**, then **Add condition**.
  * Type Event in the **Search data** box. Then, select your “> event”. It should appear as an option with the webhook you created earlier.&#x20;
  * Select **“Is”**, then type the following in the open box: `intercom.recorder.recorded`.&#x20;
  * Click **Done -> Save and Continue**.
* Click **Add branch**.&#x20;
  * Repeat the same process starting with clicking into **Missing Condition**.&#x20;
  * When you set the **“Is”** value, type `intercom.recorder.opted_out`.&#x20;
  * Click **Done -> Save and Continue**.

### Design what happens after Jam

Now that Intercom can understand what your customer chose to do when prompted with Jam, you must decide what action we should take next. Our recommendation is as follows:

#### **If the customer recorded a Jam, assign a team member to review.**

* Click the red arrow next to the branch entitled `intercom.recorder.recorded`.
* Select **Message**.&#x20;

Include a message that signifies your team is reviewing the Jam recording and that you will respond shortly.

{% hint style="info" %}
Jam sends automatic messages when your customer begins recording, and when they submit a recording. The below is not customizable. Adjust your personalized message to follow the “Screen recorded succesfully” message.
{% endhint %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvPY8MKAcMWeBOz9M1N6i%2Fimage.png?alt=media&#x26;token=4e5be734-a771-4187-801a-4f213be5fe83" alt=""><figcaption></figcaption></figure>

**If the customer opts to submit their issue via text instead of recording a Jam.**

* Click the red arrow next to the branch entitled `intercom.recorder.opted_out`.&#x20;
* Select **Message**.
* Include a message that signifies the customer will need to explain the issue.&#x20;
* Then, click **Add Step**.
* Click **Collect customer reply**.
* Next, click the red arrow to add another step in your workflow. At this stage, we’d advise that you Assign a team member, like shown in the first workflow outlined above.

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6umqdtyuQQuXU6a3c6HC%2FScreenshot%202025-09-12%20at%2010.26.32.png?alt=media\&token=1dd47c45-d061-4567-a736-032208144fd3)

### Current Limitations

For now, Jam for Intercom can only be activated with Fin Workflows, integration via Fin Tasks is currently not possible.

###

---

# Source: https://jam.dev/docs/integrations/intercom.md

# Source: https://jam.dev/docs/jam-for-customer-support/intercom.md

# Intercom

{% embed url="<https://www.youtube.com/watch?v=jxzyIdzRZnI>" %}

## Getting started

{% hint style="info" %}
Jam for Intercom supports multiple channels, including **Intercom Messenger**, **email,** and **Slack**.
{% endhint %}

### How to use Jam + Intercom

1. From the team dashboard, go to the team settings and select Connected Apps tab. Click on Intercom and go through the authorization flow.<br>

   <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fywr9IQOjAnY7PgtuIszS%2FJamCSUP-1.gif?alt=media&#x26;token=f2b5ee76-1314-4190-b338-09483ce65c11" alt="" width="563"><figcaption><p><br></p></figcaption></figure>
2. Once the integration is connected you can start using Jam in chats with your customers.\
   Pin Jam in Intercom for easy access: in the Intercom inbox sidebar, scroll to bottom and click on Edit apps. Pin the Jam app, and drag it to the top of the sidebar.<br>

   <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FtHjogZq7Ng0RBjAKslUw%2FJamCSUP-2.gif?alt=media&#x26;token=7e780985-49b4-400e-a86a-6d2253d840d4" alt="" width="563"><figcaption><p><br></p></figcaption></figure>

{% hint style="info" %}
If you're looking to integrate Jam into your Fin workflow please follow this guide: [How to integrate Jam with Fin](https://jam.dev/docs/jam-for-customer-support/intercom-fin-ai)
{% endhint %}

3. Once your users report an issue, an agent can request a screen recording with Jam\
   \&#xNAN;*Tip: you can also customize the message your users see*<br>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F5ljiFKFtMz1F7lSutcdV%2FCSUP-3.gif?alt=media&#x26;token=f8b748e1-3d21-4040-b90b-73d7e300f842" alt="" width="563"><figcaption><p><br></p></figcaption></figure>

4. Once user submits the recording, an agent receives a note with the Jam<br>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fc2Ca7EpKgLVyTV4JBzg9%2FJamCSUP-4.png?alt=media&#x26;token=5793a560-a55f-45dd-b77c-d24a1b298594" alt="" width="563"><figcaption><p><br></p></figcaption></figure>

5. Resulting Jam contains the screen recording + system metadata\
   Tip: you can also get console and network events in your Jams with [jam.js](https://jam.dev/docs/jam-for-customer-support/capture-logs-network-requests-from-customer-jams)

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FbO05I3cqBr3g8AJPAM8p%2FJamCSUP-4.gif?alt=media&#x26;token=63dbed39-fc16-46d3-9c36-6a11b2f78768" alt="" width="563"><figcaption></figcaption></figure>

And that's it. Now you have all the info you need to fix customer issues faster.&#x20;

If you need any help, or want to share feedback, feel free to reach out to <hello@jam.dev>!

---

# Source: https://jam.dev/docs/record-a-jam/jam-for-ios/ios-shortcuts-for-jam.md

# iOS Shortcuts for Jam

### Add Jam Widget to Control Center

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FeN23X52ZTEoh23YMyo4D%2Fimage.png?alt=media&#x26;token=cb09bfa1-80e7-4795-8469-6918dd084c6b" alt=""><figcaption></figcaption></figure>

**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:**

1. Swipe down from top-right corner (or up from bottom on older devices) to open **Control Center**
2. **Long-press** on any space in Control Center
3. Tap **Add a Control** (plus button)
4. Find **Jam** and tap the **+** button
5. The strawberry icon now appears in your Control Center

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

***

### Hey Siri, Record a Jam

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkR0see89JSPLZtay7kwf%2Fimage.png?alt=media&#x26;token=4d2166cb-5519-4a19-962c-1e5d1093972e" alt=""><figcaption></figcaption></figure>

**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:**

1. Say **"Hey Siri, Record a Jam"**
2. First time: iOS will ask for permission—tap **Allow**
3. Jam opens to the recording screen
4. Tap **Start Broadcast** to begin recording

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

***

### Add Jam Widget to Homescreen

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FRixHRKTT0YIHRRXQC0Qc%2Fimage.png?alt=media&#x26;token=8640aadd-38d6-49eb-90bb-7c204b64b14f" alt=""><figcaption></figcaption></figure>

**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:**

1. Long-press any empty area on your homescreen
2. Tap the **+** button (top-left corner)
3. Search for **Jam** and select it
4. Choose **Small** or **Medium** widget size
5. Tap **Add Widget**
6. Position where convenient

**To use:** Just tap the widget and tap **Start Broadcast** to begin recording.

***

### Record a Jam with your Action Button

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FXoFYsoMw8H41aV9vbhAW%2Fimage.png?alt=media&#x26;token=a87d0793-580f-48c8-92bc-30c0b57d0537" alt=""><figcaption></figcaption></figure>

**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:**

1. Go to Settings
2. Search for action button
3. Associate the action button with "Record a Jam" Shortcut

**To use:** Just press the Action Button and tap **Start Broadcast** to begin recording.

---

# Source: https://jam.dev/docs/record-a-jam/jam-ai.md

# Jam AI

{% hint style="info" %}
Jam AI is available on all [paid plans](https://jam.dev/pricing). &#x20;

With Jam's free plan, you can create 5 AI tickets per month.  Try unlimited Jam AI for free, by starting a 14 day trial of Jam for Teams.
{% endhint %}

***

{% embed url="<https://www.youtube.com/watch?v=VtQ6kO8Ye1U>" %}

### 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, screenshot, or instant replay
* **AI Repro Steps:** AI generates a list of steps to reproduce the captured bug

{% hint style="warning" %}
AI Repro Steps are not available for screenshot Jams.
{% endhint %}

### Managing AI Features

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

{% tabs %}
{% tab title="Team Settings" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FWj6zBK4n7VYv2pRF4qIy%2FSetting_%20AI%20Team%20Workspace.png?alt=media&#x26;token=ce1ec658-76af-47a8-aaa0-c3e481e4935b" alt=""><figcaption></figcaption></figure>

**Team-Level Control**

1. Control Jam AI for your entire team through admin settings.
2. Go to Team Settings
3. In general scroll down to the data section
4. Toggle Jam AI on or off
5. This setting applies to all team members and overrides individual preferences in a team workspace.
   {% endtab %}

{% tab title="Individual Captures" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkWolCZ4IF4jcv10jt7B9%2FSettings_%20AI%20Capture.png?alt=media&#x26;token=d75e57ee-368d-413a-8f65-dbc8a668be61" alt=""><figcaption></figcaption></figure>

**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.
   {% endtab %}
   {% endtabs %}

### FAQs

<details>

<summary>Are Jam's AI features free?</summary>

You can try our Team plan for free for 14 days which includes Jam AI.\
\
Users on the free plan get 5 trial uses of Jam AI. Pro and Team plans have 200 uses per month per user. Our enterprise plans include unlimited AI usage.\
\
Working on an open-source project? Jam will always remain free for open-source projects. [Apply here](https://jam.dev/oss) for Team plan access.

</details>

<details>

<summary>How is my data used?</summary>

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](https://jam.dev/docs/company/ai-policy) page.

<br>

</details>

<details>

<summary>Where can I learn more about Jam's AI policies?</summary>

To learn more about Jam's AI approach, including data usage and privacy, visit our [AI policies](https://jam.dev/docs/company/ai-policy) page.

</details>

---

# Source: https://jam.dev/docs/record-a-jam/jam-for-ios.md

# Jam for iOS

{% hint style="info" %}
Visit the App Store to [download](https://apps.apple.com/app/id6469037234) Jam for iOS for your iPad or iPhone. 🤳
{% endhint %}

{% embed url="<https://www.youtube.com/watch?v=Xuk7cO50Z9M>" %}

### **What can you do with Jam for iOS?**

Meet Jam for iOS - the fastest way to capture dev-ready bug reports from mobile and send them to your issue tracker. Every ticket automatically includes technical details (OS, device, battery levels, etc.), so you don’t have to. This gives devs all the context they need to fix issues faster.<br>

* **Record your screen** to capture and share mobile bugs with ease.
* **AI-generated title & summary**: When you use voice-over during the screen recording, Jam will automatically transcribe and summarize the content, and generate a title and description for your Jam. No more typing required.
* **Auto-captioning**: When you're narrating your recording, Jam automatically generates captions that make it easier for others to understand what's happening in Jam, even without audio.
* **Trim, annotate, and add comments** to clarify the issue you want to share.
* **Create** a shareable link or send straight to your favorite issue tracker in seconds.
* **Watch** existing Jams in your workspace.

### AI-assisted Title, Description, and Captions

If you are using the microphone to voice-over a Jam, the AI will automatically transcribe and summarize the content and fill in the Jam's title and description. In addition, the video will get automatic captions.

Here is the list of supported languages (if a region isn’t supported, it will use the nearest equivalent - favouring a model that is already installed):<br>

* English, French, German, Italian, Portuguese, Spanish, Japanese, Korean, Chinese (Simplified and Traditional)

### How to record a Jam on iOS?

1. Open Jam, click the big strawberry 🍓
2. Click "Start Broadcast" to Jam.
3. Navigate to your target app/website to record the issue and provide a voice-over of the details needed to understand what's going on.
4. When you're done, stop broadcasting directly or by navigating back to the Jam app.
5. Trim the video, add description,  and click "Create Link".
6. Wait a few seconds until your Jam is ready to share. We will automatically copy the link to your clipboard if Jam is in focus.

<div><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fk4c83hZTRQF81hL2yrSg%2FIMG_2818.PNG?alt=media&#x26;token=ade99466-2505-47e1-ad72-a24df1030358" alt=""><figcaption></figcaption></figure> <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FpERnUDzslYuVMltAdUJ0%2FIMG_2819.PNG?alt=media&#x26;token=c4da3dd2-f915-4ac3-9a73-1cbf3256c680" alt=""><figcaption></figcaption></figure> <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FylLSWGr93Dp87XcyJLEl%2FIMG_2820.PNG?alt=media&#x26;token=1e3a366e-c963-4571-b002-025dcbca8336" alt=""><figcaption></figcaption></figure> <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fe8g4BHTGkiK9qGggdzLZ%2FIMG_2822.PNG?alt=media&#x26;token=b30ecdfb-c6ab-4c20-8b54-72d01d1f69d2" alt=""><figcaption></figcaption></figure> <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FKytWNSZ0N84txgKeQZV3%2FIMG_2823.PNG?alt=media&#x26;token=a2809f3c-5d72-4f63-b94a-a174d74607f1" alt=""><figcaption></figcaption></figure> <figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6rvoe60BtAXyOvg3oPxQ%2FIMG_2825.PNG?alt=media&#x26;token=02cbb93d-a5de-41d3-9e3d-509560f9f195" alt=""><figcaption></figcaption></figure></div>

---

# Source: https://jam.dev/docs/debug-a-jam/devtools/jam.metadata.md

# Jam.Metadata

With one function call, `jam.metadata()`, you can ensure that every Jam submitted from your website includes the metadata you need to debug the bug. Jam.Metadata works on all types of Jams, including requested Jams from [Recording Links](https://jam.dev/docs/jam-for-customer-support/recording-links), [Jam for Customer Support](https://jam.dev/docs/debug-a-jam/devtools/broken-reference) and the Jam browser extension.

You can log anything in Jam.Metadata: simple static values like User ID, to any data like redux or react state. Whatever you need to debug, just send it to Jam.Metadata so it's always there for you in any ticket.

{% embed url="<https://youtu.be/P0Uu4du__9M>" %}

## Getting Started

1. First, install the Jam SDK into your project:

{% code fullWidth="false" %}

```bash
npm install '@jam.dev/sdk'
# or:
yarn add '@jam.dev/sdk'
```

{% endcode %}

2. Once the script is included, you can start using the `jam.metadata` function to include debug information with every Jam a user files on your site:

{% code lineNumbers="true" %}

```tsx
// In the root of your app, the place where
// you would initialize your app's stores and
// render React onto your root element
import { jam } from "@jam.dev/sdk";

// We call the jam.metadata function once.
// The function we pass into it is called whenever
// a Jam is captured, so the data inside is always
// live and never stale.

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

{% endcode %}

3. Now, your metadata will be shown inside every Jam filed from your site!

## What data can you include in Jam.Metadata?

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

* State from your app stores (for example: user ID, team ID, the last 5 items in your user's checkout cart, which feature flags are enabled, etc.)
* Values from localStorage
* Whatever data you need to debug your bugs!

## Test it out live, Right now!

To see this live, try going to our [example site](https://jamdotdev.github.io/sdk/todo-mobx-example/index.html) and creating a Jam! This example site already has Jam.Metadata integrated, so as soon as you capture any kind of Jam, we'll include up-to-date debugging info.

Your Jam should include metadata that looks like the following:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fmqic05caLu724jQ0aVXi%2Fimage.png?alt=media&#x26;token=c10a61bd-7e88-432b-8ff3-3ac2827ccae7" alt="" width="375"><figcaption><p>Your site's metadata, included! Try creating more todo items to see how todoItemCount changes</p></figcaption></figure>

Objects provided will be expanded and pretty-printed when you click on them:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fs8uUvzirhT9VnyL9Govp%2Fimage.png?alt=media&#x26;token=48d8e433-63a6-48d7-abbf-97a0e941a5fb" alt="" width="375"><figcaption><p>Here, we've snapshotted our app's last todo item, in case rendering it caused the bug!</p></figcaption></figure>

The live code for is [here](https://github.com/Strawberry-Jam-Manufacturers/sdk/tree/main/docs/todo-mobx-example), and the `jam.metadata()` call is [here](https://github.com/Strawberry-Jam-Manufacturers/sdk/blob/main/docs/todo-mobx-example/src/index.tsx), for your reference. This demo shows a realistic example of how to include data from a store. In this case, we use MobX for state management, but you can pull from Redux, Zustand, or any other store you prefer.

## When is metadata captured?

Metadata is captured when a bug reporter decides to create a Jam.

## Limits, Constraints, and Errors

When calling `jam.metadata()`, keep in mind that the returned metadata object must be:

1. An `Object` instance (for example, `{ a: 1, b: 2}`, and not `window`, which is a `Window` instance)
2. Under 10kb in size, when serialized.
3. Serializable. If `JSON.stringify` can't stringify it, we can't store it!

If your app throws an error, or the above conditions aren't met, Jam will both log in your browser's live console, and display an error when the Jam is captured:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FoVG8sHte0LfRJ9Hsp6A9%2Fimage.png?alt=media&#x26;token=b736ee90-deae-49b5-84f0-2a62aa4f829c" alt="" width="375"><figcaption><p>It says "developers" in monospace, so you know it's for you ;)</p></figcaption></figure>

As always, if you have suggestions or requests for the Jam.metadata feature, or the direction our SDK should evolve in, our inbox is open at <hello@jam.dev>!

---

# Source: https://jam.dev/docs/integrations/jira-service-desk.md

# Source: https://jam.dev/docs/jam-for-customer-support/jira-service-desk.md

# Jira Service Desk

1. Create a new Recording Link from the Jam browser extension
2. Copy & Paste the customer conversation URL in the Recording Link description (e.g. <https://yourcompany.freshdesk.com/agent/tickets/125324>
3. Share the Recording Link in the customer conversation
4. When the recording is ready, you will receive an email with the customer recording with a reference to the corresponding customer conversation

{% hint style="info" %}
If you want to capture logs and network requests from your Recording Links, follow this [set up guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs).
{% endhint %}

---

# Source: https://jam.dev/docs/integrations/jira.md

# Jira

{% embed url="<https://www.youtube.com/watch?v=XckdhyMpbeo>" %}

You can connect Jira and Jam in order to instantly create Jira tickets right from Jam's browser extension. Every Jira ticket you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant Jira fields right from Jam – like assignee, labels, priority and more. Our goal is to make you 20x faster at logging bugs to Jira.

## How to use Jam + Jira&#x20;

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

&#x20;     [getting-started](https://jam.dev/docs/get-started/getting-started "mention")

2. Next, capture your bug with Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FKudedVPREisJzX7GrzyP%2Fjira-1.gif?alt=media&#x26;token=75708029-5c79-4411-9bea-f71e76381873" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to Jira.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FPfcfW47vuBdY3begN3ny%2Fjira-2.gif?alt=media&#x26;token=880aef86-4992-447c-aa7e-0ab193fafab4" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Jira.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6Sa20OJCkeAbXVkz3QKh%2Fjira-3.gif?alt=media&#x26;token=8698b8a2-46fe-4d73-877f-fef0f26dd036" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Jira, you will be able to setup your Jira ticket right from Jam.\
   Choose the project, issue type, priority, labels, etc., right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fk88R9HqBIDvVEZH2TNGA%2Fjira-4.gif?alt=media&#x26;token=1754ee06-2ddc-4e1f-9407-1956ba7442b6" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields"  to manage which fields from Jira are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FYzhUdew0ORRAp7IGh5PX%2Fjira-5.gif?alt=media&#x26;token=c5452a99-3d1d-4c97-b771-ea228d3f32dc" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create issue" and once Jam creates your Jira ticket, it will automatically open in a new tab. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FOJo2Wlq17GBRTJ53atjt%2Fjira-6.gif?alt=media&#x26;token=d86aa14e-bb2b-4f2d-8592-d138b46cbf7c" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to Jira

You can automatically create Jira tickets from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a Jira ticket.
2. Click "Send to App" and select Jira.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FCNC622gdECxbxwUSL8gF%2Fjira-tools-1.gif?alt=media&#x26;token=c03eeded-9ba4-45b8-9c5e-a31e64574844" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Jira before, it will first redirect you to log in with Jira.
4. Enter the details of your Jira ticket: project, issue type, priority, labels, etc<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FbjlOhE3XHZYMDTmbHRgs%2Fjira-tools-2.gif?alt=media&#x26;token=0aa1ddc3-293b-4245-ab46-b7f2be3e752e" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields"  to manage which fields from Jira are shown in Jam.
6. Click "Create issue" to create your Jira ticket.&#x20;

## How to connect multiple Jira sites to Jam

Each Jam team workspace can connect to one Jira site. That means if you're working with multiple companies or clients where each one uses its own Jira site, you will need to create a new Jam team workspace for each company/client, and connect each Jam team workspace to the relevant Jira site for that company/client.

Here's how to create multiple Jam team workspaces and connect them to separate Jira sites:

1. Go to the Jam dashboard: [jam.dev](https://jam.dev)
2. Click "Invite Teammates" or "Add a Team" <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1UIMx7obwBDvjUTs8ysJ%2Fteam-1.gif?alt=media&#x26;token=426fb51c-ce7b-43c2-806c-1d878fa3d516" alt="" width="316"><figcaption></figcaption></figure></div>
3. Jam will walk you through the steps of creating a team.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjUlv1G9GMruXJkn4EBHd%2Fteam-2.gif?alt=media&#x26;token=64c0f45d-d123-488f-b01c-d5a934cd66b2" alt="" width="375"><figcaption></figcaption></figure></div>
4. Go to your newly created team settings. Click on "Connected Apps". Then click on "Jira". The Jira authentication flow will open in a new tab. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FUFFntrOD2oKIdiFO2zCq%2Fjira-team-1.gif?alt=media&#x26;token=6ae34728-43b3-4eb9-9369-0f966f9e3e41" alt="" width="375"><figcaption></figcaption></figure></div>
5. Select the Jira site you want to connect to.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F9d3mIo2WFkiRWIyPT5P9%2Fjira-team-2.gif?alt=media&#x26;token=4ff40e36-d6df-4832-90f1-7e60b0376d79" alt="" width="375"><figcaption></figcaption></figure></div>
6. After you are done connecting to Jira, you will be able to see which Jira site is connected to that Jam team workspace.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F4HvlSNyyqakCoifMpwp6%2Fjira-team-3.gif?alt=media&#x26;token=733d37d6-297b-45f3-a187-1cb2b9a7f240" alt="" width="375"><figcaption></figcaption></figure></div>
7. Repeat this process of creating a new Jam team workspace + connecting the corresponding Jira site for every Jira site you need to connect to Jam.&#x20;

If you need to swap which Jira site is connected to a Jam team, follow these 3 steps:

First, you will need to disconnect Jira from the Jam team settings.&#x20;

Then you will need to login to Jira and disconnect Jam by going to  <https://id.atlassian.com/manage-profile/apps>, finding Jam, and clicking on "Remove access".&#x20;

Finally, you can go back to the Jam settings page and re-connect Jam to the new Jira site.

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkrUcMqa19RPuXb9xtcDJ%2Fimage.png?alt=media&#x26;token=031e2a55-4a4f-495d-a9e9-7fe259078122" alt="" width="479"><figcaption></figcaption></figure></div>

---

# Source: https://jam.dev/docs/record-a-jam/keyboard-shortcuts.md

# Keyboard shortcuts

### Overview

Control the Jam extension faster with keyboard shortcuts. Skip the clicks and capture bugs, record sessions, or take screenshots directly from your keyboard. Perfect for streamlining your debugging workflow.<br>

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FtZuIb4die417pd1wiT6B%2Fkeyboard-shortcuts.gif?alt=media\&token=f0fa07d6-0881-4562-a760-6bfbbf6d5e44)

### Key Benefits

* **Faster bug capture:** Skip mouse clicks and capture issues instantly
* **Workflow efficiency:** Keep your hands on the keyboard while testing
* **Customizable controls:** Set shortcuts that match your preferred workflow
* **Quick discovery:** Hover over extension buttons to see default shortcuts

### Default Shortcuts

{% hint style="info" %}
Chrome limits extensions to 3 default keyboard shortcuts. That's why Desktop Recording doesn't have a default shortcut . We prioritized the most commonly used features by default.
{% endhint %}

| Action             | Default shortcut                                   |
| ------------------ | -------------------------------------------------- |
| Capture screenshot | <kbd>Shift</kbd> <kbd>⌘</kbd> <kbd>S</kbd>         |
| Record tab         | <kbd>Shift</kbd> <kbd>⌘</kbd> <kbd>Space bar</kbd> |
| Instant replay     | <kbd>Shift</kbd> <kbd>⌘</kbd> <kbd>X</kbd>         |

You can find the current keyboard shortcuts by hovering over each button in the Jam extension. The shortcut will appear in a tooltip.

### Customizing Shortcuts

You can modify keyboard shortcuts to match your workflow preferences through your browser's extension settings.

**Edit Chrome Extension Shortcuts**

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FUe2TDriWWvlylRd2XlWc%2Fedit-keyboard-shortcuts.gif?alt=media\&token=4304fffc-0fe5-431e-8153-b0dcdeaedffc)

1. Go to <chrome://extensions/shortcuts> in your address bar
2. Find the Jam extension in the list
3. Click in the shortcut field next to the action you want to change
4. Press your preferred key combination
5. The new shortcut saves automatically

You should now see your custom shortcuts when hovering over extension buttons.

### FAQs

<details>

<summary>Why doesn't Desktop Recording have a default keyboard shortcut?</summary>

Chrome limits extensions to 3 default shortcuts per extension. We chose to assign defaults to the most frequently used features: Instant Replay, Screenshot, and Record tab.

</details>

<details>

<summary>Can I assign a shortcut to Desktop Recording?</summary>

Yes. Go to your browser's extension shortcuts settings and create a custom shortcut for Desktop Recording.

</details>

<details>

<summary>What happens if my shortcut conflicts with another extension?</summary>

The browser will typically warn you about conflicts. You'll need to choose a different key combination that doesn't conflict with existing shortcuts.

</details>

---

# Source: https://jam.dev/docs/guides/tutorials/limit-jam-to-specific-sites.md

# Limit Jam to Specific Sites

By default, Jam runs on all websites. If you are looking for a way to make it only run on certain websites, you can do this by changing the settings for the Jam extension from your browser. Follow the steps below for Chrome browser to only allow Jam to run on specific websites:

1. Enter "chrome://extensions" in your URL bar and hit enter. This will take you to a page that will show you all the chrome extensions that are installed on your browser.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FhAGQoW1ZySaE749qgPq9%2Fimage.png?alt=media\&token=ba6c18b3-f6e9-4817-8c20-2a45f9f3809e)
2. Click on the 'Details' button for the Jam chrome extension.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2F9ipxBkQ9w9ZKUoauP60g%2Fimage.png?alt=media\&token=f9f77832-4ca6-48ca-8b11-9a29418c2888)
3. Under the section 'Site access', use the dropdown menu to change from 'On all sites' to 'On specific sites'.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FVMIw0aVXebWkPP9HxyFF%2Fimage.png?alt=media\&token=e8c1f604-0009-4da6-9ff9-e2fde6361004)
4. Once you select the 'On specific sites' option, you will see a modal where you can add the URL of the website where you want Jam to be enabled.&#x20;
5. Enter '<https://*.jam.dev/*>' and click on 'Add'.
6. Enter the URL you want to allow access to and click on 'Add'.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FbiCYhxrV0Xv2G1lT7m9s%2Fimage.png?alt=media\&token=2d245374-211f-494b-849a-3b4e830ff825)
7. After you add the website, you can add more websites by clicking on the 'Add a new page' button.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FHv8KwEvE46krOtM2lJ2k%2Fimage.png?alt=media\&token=7944728d-466e-4a97-afcd-621be7ef66c3)
8. If you change your mind and want to enable Jam for all websites, simply use the dropdown under 'Site access' and change it back to 'On all sites'.

---

# Source: https://jam.dev/docs/integrations/linear.md

# Linear

{% embed url="<https://youtu.be/3oODiEiD8n0>" %}

You can connect Linear and Jam in order to instantly create Linear tickets right from Jam's browser extension. Every Linear ticket you create with Jam automatically includes:

* Console logs&#x20;
* Fully inspectable network requests&#x20;
* URL, timestamp and country&#x20;
* Device, OS, Browser&#x20;
* Viewport size&#x20;
* Network speed&#x20;

That way, it's perfect for engineers to help them debug issues faster.

You can configure all the relevant Linear fields right from Jam – like assignee, labels, priority and more. Our goal is to make you 20x faster at logging bugs to Linear.

## How to use Jam + Linear

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

{% content-ref url="../get-started/getting-started" %}
[getting-started](https://jam.dev/docs/get-started/getting-started)
{% endcontent-ref %}

2. Next, capture your bug with Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJm06A238yDNnQf2cM2eJ%2Flinear-1.gif?alt=media&#x26;token=464ca04d-8032-4b7a-b2f5-fb364ad5690b" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to Linear.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FGLfZ18EaCzuDd9loWYsb%2Flinear-2.gif?alt=media&#x26;token=8c8b72f0-b766-4b37-9e78-afeb699290cb" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Linear.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FupYZC3qr30GoNiPXtFP2%2Flinear-3.gif?alt=media&#x26;token=1b3228ea-6ba3-46f2-9512-01a418bd7a9c" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Linear, you will be able to setup your Linear ticket right from Jam. Choose the assignees, labels, priority, project, etc., right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FlEX9S9xDhn1ZosiZJJYf%2Flinear-4.gif?alt=media&#x26;token=179104f5-80f8-4c04-b4c2-d94184152019" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields" to manage which fields from Linear are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FMPEItdx1qKxGPVB8EqVj%2Fedit-fields.gif?alt=media&#x26;token=7849e5ad-75c6-430f-9f25-dbb461112543" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create issue" and once Jam creates your Linear ticket, it will automatically open in a new tab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJkOMrAW8Dbb9nTPqLfeC%2Flinear-5.gif?alt=media&#x26;token=18f06a9b-5a6c-4af2-b733-0588662ba1fc" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to Linear

You can automatically create Linear tickets from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a Linear ticket.
2. Click "Send to App" and select Linear.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FsdUZtJSy1NRhcThFFWIk%2Fsend-to-linear-1.gif?alt=media&#x26;token=d41804e2-021b-48d0-8af3-5db585199220" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Linear before, it will first redirect you to log in with Linear.
4. Enter the details of your Linear ticket: title, assignee, priority, labels, etc.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjxNDL4XTXJhM5zJ531KH%2Fsend-to-linear-2.gif?alt=media&#x26;token=397f180c-89a2-45bc-953a-1489a94a69ea" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields" to manage which fields from Linear are shown in Jam.
6. Click "Create issue" to create your Linear ticket.

## How to connect multiple Linear workspaces to Jam

Each Jam team workspace can connect to 1 Linear workspace. That means if you're working with multiple companies or clients where each one uses its own Linear workspace, you will need to create a new Jam team workspace for each company/client, and connect each Jam team workspace to the relevant Linear workspace for that company/client.

Here's how to create multiple Jam team workspaces and connect them to separate Linear workspaces:

1. Go to the Jam dashboard: [jam.dev](https://jam.dev)
2. Click "Invite Teammates" or "Add a Team" <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1UIMx7obwBDvjUTs8ysJ%2Fteam-1.gif?alt=media&#x26;token=426fb51c-ce7b-43c2-806c-1d878fa3d516" alt="" width="316"><figcaption></figcaption></figure></div>
3. Jam will walk you through the steps of creating a team.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FjUlv1G9GMruXJkn4EBHd%2Fteam-2.gif?alt=media&#x26;token=64c0f45d-d123-488f-b01c-d5a934cd66b2" alt="" width="375"><figcaption></figcaption></figure></div>
4. Go to your newly created team settings. Click on "Connected Apps". Then click on "Linear". The Linear authentication flow will open in a new tab. Login to the Linear workspace you want to connect that team to.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FlYO5nsugwsOdcIAUrNy7%2Fteam-linear-3.gif?alt=media&#x26;token=af7fa9f1-9848-4890-a1c8-bcc8deb8f787" alt="" width="375"><figcaption></figcaption></figure></div>
5. After you are done connecting to Linear, you will be able to see which Linear workspace is connected to that Jam team workspace. If you need to swap which workspace is connected, you can simply disconnect the Linear connection from the Jam connected apps settings, and re-connect to the correct Linear workspace.\
   &#x20;

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F68kUM2caxEXhttguBSXt%2Fwhich-linear.gif?alt=media&#x26;token=7ac6450e-56d9-48a7-a31a-0712483b278d" alt="" width="375"><figcaption></figcaption></figure></div>
6. Now, when you create Jams, you can choose which Jam team workspace (and thus, which Linear workspace) to send each Jam to.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FgWR4EOxP3y2xPFszZRZg%2Fchoose-linear.gif?alt=media&#x26;token=feed2f01-e880-4e40-8274-ed340cf6a405" alt="" width="375"><figcaption></figcaption></figure></div>
7. Repeat this process of creating a new Jam team workspace + connecting the corresponding Linear workspace for every Linear workspace you need to connect to Jam.\ <br>

---

# Source: https://jam.dev/docs/integrations/logrocket.md

# LogRocket

Create complete bug reports with LogRocket session data directly from your web app, simply by recording your screen with Jam’s browser extension. Jam auto-includes all the technical context developers need to debug.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FARHcLiTcU9ynBVlRxbWK%2FHighlight-01.png?alt=media&#x26;token=ed1d3328-0f70-46cc-b7d6-4fe59466b9d1" alt=""><figcaption></figcaption></figure>

If your website is using LogRocket for customer analytics, your Jams will automatically include LogRocket session link. You’ll find the link to the LogRocket session in the info panel in Jam logs.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F10ASCMfwKpLkHvNZUFRL%2FHighlight-03.png?alt=media&#x26;token=39d2a75b-fe3c-4503-9374-b4896578efc4" alt=""><figcaption></figcaption></figure>

You don't have to connect anything to get started with the Jam + LogRocket integration. The URL to the LogRocket session recording is just going to be there for your devs every time you report a bug with Jam.

---

# Source: https://jam.dev/docs/debug-a-jam/mcp.md

# MCP

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fry7sdmxcTVw3WZoMYff1%2Fimage.png?alt=media&#x26;token=a800886e-5217-443b-80f2-e823182a5feb" alt=""><figcaption></figcaption></figure>

### Overview&#x20;

Jam MCP (Model Context Protocol) lets your developer tools and AI agents open a [Jam recording](https://jam.dev/docs/get-started/welcome-to-jam) and automatically load its data into context (video, user events, console logs, errors and network requests). As a developer, you’ll debug faster without hand-typing steps to reproduce, copy-pasting stack traces, or screen-sharing.

Your AI models and agents can use Jam’s MCP server to access your Jam recordings and their data in a simple and secure way.&#x20;

Paste an existing Jam link into supported MCP clients like VS Code, Cursor, Windsurf, or Claude Code, and the Jam's context appears right where you’re working.&#x20;

### Prerequisites

<details>

<summary>Record a Jam first</summary>

1. [Install](https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci) the **Jam** Chrome extension.
2. Hit **Record** to capture your screen and voice.
3. Stop the recording, and your Jam link is ready for an agent to consume via MCP.

</details>

### 1. Configure

<details>

<summary>ChatGPT</summary>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkreA2swop1AL4Yd3YW9K%2FJamChatGPT-connector.gif?alt=media&#x26;token=45277eb5-7491-4d9d-9ae4-804ba09e79c6" alt=""><figcaption></figcaption></figure>

**Steps:**

1. From the home page go to **Settings**
2. Click **Apps &** **Connectors**&#x20;
3. Select **Jam** and click the **Connect** button
4. Sign in to Jam and allow access to your workspace

</details>

<details>

<summary>Claude Desktop</summary>

<div data-full-width="true"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FRYaPU7i4WX1SbVWR91Du%2FClaude%20MCP.gif?alt=media&#x26;token=e6011757-7fdb-42cb-9c1f-08b184b528c2" alt=""><figcaption></figcaption></figure></div>

\
**Steps:**

1. From the home page click  <i class="fa-sliders-simple">:sliders-simple:</i>  **search and tools** on web or desktop
2. Click **+Add connectors**&#x20;
3. Find **Jam** in the Connector Directory and click the  <i class="fa-plus">:plus:</i>  button to connect
4. Sign in to Jam and **pick the workspace** Claude should access

</details>

<details>

<summary>Claude Code</summary>

**Steps:**

1. Install [Claude Code in your IDE](https://docs.anthropic.com/en/docs/claude-code/ide-integrations)
2. In your terminal run

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

</details>

<details>

<summary>Cursor</summary>

<a href="cursor://anysphere.cursor-deeplink/mcp/install?name=jam&#x26;config=eyJ1cmwiOiJodHRwczovL21jcC5qYW0uZGV2L21jcCJ9" class="button primary" data-icon="square-terminal">Add to cursor</a>

***

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

Once you make the above changes, make sure to restart Cursor to use Jam.

</details>

<details>

<summary>Visual Studio Code</summary>

1. <kbd>CTRL/CMDP</kbd> + <kbd>P</kbd> and enter `>MCP: Add Server`
2. Select **HTTP (HTTP or Server-Sent Events)**
3. Enter `https://mcp.jam.dev/mcp`&#x20;
4. Enter `Jam`&#x20;
5. Your `mcp.json` file should look like this:&#x20;

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

</details>

<details>

<summary>Windsurf</summary>

1. <kbd>CTRL/CMDP</kbd> + <kbd>P</kbd> and enter `>MCP: Add Server`
2. Select **HTTP (Server-Sent Events)**
3. Enter `https://mcp.jam.dev/mcp`&#x20;
4. Enter `Jam`&#x20;
5. Your `mcp.json` file should look like this:&#x20;

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

</details>

<details>

<summary>OpenCode</summary>

1. Edit your `opencode.json`:&#x20;

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

2. Run `opencode mcp auth jam` to start oauth2 authorization flow

</details>

{% hint style="info" %}
Jam MCP is backwards compatible with the deprecated [HTTP+SSE transport](https://modelcontextprotocol.io/specification/2024-11-05/basic/transports#http-with-sse)&#x20;
{% endhint %}

### 2. Getting Started

Once you have configured your MCP:

1. Copy one or multiple Jam links
2. Prompt your agent and paste the Jam link. \
   \&#xNAN;*See our* [*prompt tips*](#id-4.-tips) *and examples below*
3. Authenticate your IDE with Jam
4. Approve any of the tool requests the agent makes

### 3. Available Features in Jam MCP

**Tools**

| Tool name                                                                     | Description                                                                                        |
| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| <i class="fa-comments">:comments:</i>  **getDetails**                         | Get a quick snapshot of the Jam. Who made it, what happened, and which other tools to try next.    |
| <i class="fa-rectangle-terminal">:rectangle-terminal:</i>  **getConsoleLogs** | Grab the console logs from the Jam                                                                 |
| <i class="fa-network-wired">:network-wired:</i>  **getNetworkRequests**       | List every web request from the Jam as JSON, trimmed to the essentials for fast debugging.         |
| <i class="fa-camera-viewfinder">:camera-viewfinder:</i>  **getScreenshot**    | Get every screenshot from a screenshot Jam so you can inspect                                      |
| <i class="fa-arrow-pointer">:arrow-pointer:</i>  **getUserEvents**            | Read each click, input and page navigation change in plain language.                               |
| <i class="fa-video">:video:</i>  **analyzeVideo**                             | Analyzes Jam video recordings to extract insights, detect issues, and provide structured feedback. |

### 4. Tips

Prompting tips:

1. Use Jam MCP to help with bug analysis, product feedback, and give agents context to debug issues.
2. Be as specific as you would with another engineer for the best results
3. 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

### 5. Examples

Examples of how the team at Jam uses Jam MCP:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fry7sdmxcTVw3WZoMYff1%2Fimage.png?alt=media&#x26;token=a800886e-5217-443b-80f2-e823182a5feb" alt=""><figcaption></figcaption></figure>

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

{% code title="Prompt" overflow="wrap" %}

```
Review this Jam <Jam Link Placeholder> and analyze the problem, cross-reference it with the existing codebase, and prepare a detailed plan for implementation.
```

{% endcode %}

<details>

<summary>Stack used</summary>

* Jam (recordings)
* Jam MCP
* [Cursor](https://cursor.com/agents)

</details>

***

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FKMAVyzXlQBAvvTECtXUO%2Fimage.png?alt=media&#x26;token=b7fe7039-9cf6-49e8-8119-02ae58a25ad5" alt=""><figcaption></figcaption></figure>

**Frits (Product Manager)** let’s Claude review and analyze customer Jams to spot common issues and patterns. Claude turns the findings into neatly grouped Linear tickets.

{% code title="Prompt" overflow="wrap" %}

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

{% endcode %}

<details>

<summary>Stack used</summary>

* Jam (customer recordings)
* Jam MCP
* [Claude Desktop](https://www.notion.so/Jam-MCP-Docs-Early-Access-207f727817b9802abfaacf9064c14fe7?pvs=21) (analysis & ticket drafting)
* [Linear MCP](https://linear.app/docs/mcp) (issue creation)

</details>

***

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FmEzDZHbEmzQeiVo7gWGl%2Fimage.png?alt=media&#x26;token=ad1de41e-8362-4edd-87fa-2bb9f4002120" alt=""><figcaption></figcaption></figure>

\
**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 with the implemented Feedback.

{% code title="Prompt" overflow="wrap" %}

```
I recorded product feedback in a Jam. Create an implementation plan for the changes requested in this Jam:

<Jam Link Placeholder>
```

{% endcode %}

<details>

<summary>Stack used</summary>

* Jam (recording via [extension](https://chromewebstore.google.com/detail/jam/iohjgamcilhbgmhbnllfolmkmmekfmci))
* Jam MCP
* [Claude Code](https://www.anthropic.com/claude-code) inside of Cursor

</details>

***

### 6. Feedback

Got an idea that would make Jam MCP faster, smarter or more useful? Drop it in the form below (30 seconds, tops).

<a href="https://jamdotdev.notion.site/207f727817b980c0a430fddd7ed2092a?pvs=105" class="button primary" data-icon="arrow-up-right">Request a feature</a>

***

### FAQ

<details>

<summary>Can I use MCP without the Chrome extension?</summary>

Yes. You only need an existing Jam link. Anyone (you, your team, or a customer) can record a Jam. If you want to record and [create new Jams](https://jam.dev/docs/get-started/creating-a-jam), install the Chrome extension or use our iOS app.

</details>

<details>

<summary>Can I paste multiple Jam links at once?</summary>

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

</details>

<details>

<summary>How do I review or revoke tools that can access Jam via MCP?</summary>

Go to **Settings → Integrations → AI Agents** to see connected tools. Select a tool to **revoke** or **disconnect** access at any time.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FbzISnmIbLDR0hk6JAoJH%2Fimage.png?alt=media&#x26;token=2442ce11-7865-4a1a-8efb-9b2ac5ab8d0b" alt=""><figcaption></figcaption></figure>

</details>

<details>

<summary>Does Jam MCP send my Jam data to third parties?</summary>

Some MCP tools use Google’s Gemini. We **opt out of training** on Jam customer data and take steps to de-identify it. See our[ AI Policies](https://jam.dev/docs/company/ai-policy) for more details.

</details>

<details>

<summary>Does MCP work the same with Instant Replay Jams?</summary>

Not exactly. getScreenshot and videoAnalysis are **not** available for Instant Replay Jams. Other MCP tools still work and return data/context.

</details>

<details>

<summary>How can admins control what MCP can access?</summary>

MCP mirrors your existing Jam permissions. It doesn’t grant new access. Use your normal admin controls for [members and roles,](https://jam.dev/docs/administration/members-and-roles) or [SSO](https://jam.dev/docs/administration/sso) in workspace settings. Nothing is exposed via MCP that a user couldn’t already see in the Jam web or mobile apps.

</details>

---

# Source: https://jam.dev/docs/administration/members-and-roles.md

# Members and Roles

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FqDWnIMOIDB2eFFPdaBsA%2FSetting_%20Members%20and%20Roles.png?alt=media&#x26;token=70447e13-e64a-47ac-8a29-6f4d7ae3c622" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Available to workspaces on our [Team](https://jam.dev/pricing) or [Enterprise](https://jam.dev/pricing) plans.
{% endhint %}

### **Overview**

Jam currently offers two seat types: **Viewer** (free) and **Creator/Admin** (paid). Each seat type provides different levels of access and functionality within your team workspace. Your workspace’s plan, along with the number and type of paid seats, determines your subscription cost.

Here’s how these seat types work:

<details>

<summary>Viewer (free)</summary>

The **Viewer** seat is a free role that makes collaboration easy. Viewers can access and comment on Jams but cannot create or manage them in team workspaces.

Viewers can self-upgrade to a **paid Creator seat** by taking certain actions within your team workspace, such as:

* Creating a Jam
* Creating a recording link
* Sending a Jam to an integration
* Moving a Jam into a paid team via any integration

{% hint style="info" %}
**Note:** Viewer seats are not available on pro and business legacy plans.
{% endhint %}

</details>

<details>

<summary>Creator (paid) <code>default</code></summary>

The **Creator** seat is a paid role designed for team members who actively create and manage content within your team’s workspace. Creators have full capabilities, including:

* Creating, moving, and deleting Jams and recording links
* Moving content between teams and integrations
* Actively collaborating within a paid team workspace

Creators impact your workspace’s billing, as each Creator occupies a paid seat.

{% hint style="info" %}
**Note:** By default, all new users join your workspace as creators.
{% endhint %}

</details>

<details>

<summary>Admin (paid)</summary>

The **Admin** seat is a paid, permanent role intended for managing workspace settings and members. Admins have all Creator capabilities, plus additional management privileges, including:

* Managing workspace 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.

</details>

### **Examples of seat combinations and billing impact**

Since your team workspace’s 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** and remains free, not impacting your team’s workspace billing.
2. **Free and paid seats:**
   * **Riley** is a product manager who creates Jams regularly. Riley uses a **Creator seat** and is a paid member of the workspace.
   * **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 team members and workspace 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.

{% hint style="info" %}
**Note:** On legacy Pro and Business plans, workspaces have a included seat amount

* **Pro:** 2 seats included
* **Business:** 10 seats included

If your workspace exceeds this seat quota, additional creator and admin seats are billed at an extra per-seat rate ($8 per additional seat). Viewer seats are not available on pro and business legacy plans.
{% endhint %}

### **How do 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 team via an integration
   * **Send** content to an integration, triggering active collaboration
2. **Upgrade via Admin**

   Admins can manually upgrade a Viewer to a Creator or Admin seat anytime. They can also downgrade Creators back to Viewers (free) or switch Creator roles to Admin roles.

   * On Pro and Team plans, 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.

{% hint style="info" %}
**Example:** Casey is initially assigned a Viewer seat. Casey creates a new Jam to collaborate actively with their team. By creating that Jam, Casey automatically upgrades from a Viewer seat to a Creator seat, which updates the workspace billing
{% endhint %}

### **Managing Seats**

#### **Manage seats on Team plan**

On Team plan, workspace Admins control seat management directly. Here’s how Admins can manage user seats:

1. Go to your workspace settings page.
2. Select the **Team** tab.
3. Choose the member whose seat you want to manage.
4. Click their seat type (**Viewer**, **Creator**, or **Admin**) and select a new seat type from the available options.

#### **Manage seats on Enterprise plans**

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.

{% hint style="info" %}
**Note:** You cannot downgrade someone to a Viewer seat if you want to prevent future self-upgrades. (If desired, contact support to explore advanced restrictions.)
{% endhint %}

#### **Manage seats on Legacy Plans**

On Pro and Business plans, workspace Admins control seat management directly. Here’s how Admins can manage user seats:

1. Go to your workspace settings page.
2. Select the **Team** tab.
3. Choose the member whose seat you want to manage.
4. Click their seat type (**Creator**, or **Admin**) and select a new seat type from the available options.

---

# Source: https://jam.dev/docs/company/mission-and-values.md

# Mission and Values

## Our mission

> "Facebook was move fast and break things, I think a Jam world is move fast and fix things" – Jam user

Most things in software engineering have changed 100x since the 1990s, but the way we report bugs has not.

It's still the same outdated process we used in 1990 – manually creating tickets that ultimately don't include enough context for engineers to action. This leads to wasted time, effort, and energy, and a worse user experience for customers.

It's not the 1990s anymore, and it's time for bug reporting to act like it. That's where Jam comes in.

We understand the importance of moving fast and developing great software. In today's world, progress moves at the speed of software development. Everything from education, healthcare, and finance to AI runs on software. So Jam exists to help you deliver software faster and get the future into your users' hands sooner.

Our dream is to help one million teams ship better software faster. Thank you for joining us on that mission.

## Our values

### Build in partnership with our customers

Jam is a true collaboration with our customers. We exist to serve you. And we're honored when you reach out to us and share your feedback.&#x20;

Here's how we are building Jam in concert with you, the Jam community:

* Every new user gets welcomed by a Jam founder. We read and respond to every reply.
* Every new power user hears from a Jam founder asking for feedback. Again, we truly read and respond to every reply.
* All user feedback is shared in a dedicated Slack channel for internal team discussion and action.
* We try to spend as much time as we can talking to users: over calls and in person.
* We all listen to clips from recent user interviews together as a company and discuss.

Why? Getting to know you, the people who use Jam every day gives our work a whole new meaning. So thank you to everyone in the Jam community who has taken the time to meet with us and talk to us about the product. We're blown away by the support and enthusiasm from all of you. Thank you.&#x20;

You can always reach out to the founding team at <hello@jam.dev>.

### Simplicity first, simplicity always

We're here to simplify bug reporting and take away manual steps.

We hear you – simplicity matters, and it's a first principle in everything we do.

We promise to do our best to simplify always. The simpler we can make it for you to communicate between engineers & the rest of your company, the faster you can ship. Simple is our goal. That’s how we want to enable you to move fast and do your best work.

### Ship fast, then learn & iterate in public

We're learning as we're building a company, and a product – like you all are.

So we're going to prioritize shipping, and iterating live with all of you.

That means we ask for your feedback. That means we make an effort to share our learnings building Jam with you. That way, we all become better builders together.

### We're here to do our best work

We take your time and trust seriously. We aim to build a product that meaningfully, positively enables you to move faster and ship more. That means we need to put in significant time, dedication, and a lot of hard work. There's a long journey ahead at Jam. But that's what we're here to do. We're here to deliver for you. We're on it. We're here to build. And to do whatever hard work is required in order to continuously deliver a fast and amazing experience for you.

## Company

We are on a mission to speed up software development. That's why we're building the fastest and clearest way to capture a bug.

Jam helps software teams at some of the largest and fastest growing companies such as T-Mobile, SeatGeek, Staples, Rippling, and Ramp ship higher quality software faster to better serve their collectively millions of customers.&#x20;

Jam was founded in 2020 and is backed by early investors, founders, and executives from developer-focused companies such as Apple, GitHub, Slack, Cloudflare, and PagerDuty. Institutional investors include Union Square Ventures, BoxGroup, Version One Ventures, and Village Global (backed by Bill Gates, Jeff Bezos, Mark Zuckerberg, etc).&#x20;

---

# Source: https://jam.dev/docs/record-a-jam/mobile-inspector.md

# Mobile inspector

You can use Jam to review responsive styles by using Jam alongside your browser's mobile inspector tools.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBfSSWI8EXJbXm53bqGNm%2Funnamed.gif?alt=media&#x26;token=252d9a8a-64f3-42b7-8b94-b20cd4947da0" alt=""><figcaption></figcaption></figure>

To preview your website using your browser's mobile inspection:

1. Right click on the website and select "Inspect"
2. In the top left corner of dev tools, click the mobile inspector tool:

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FNbu74f8hOsvMjCdFScqf%2FScreenshot%202023-07-07%20at%209.53.53%20PM.png?alt=media\&token=334f4a02-4a00-43a5-a839-5447cb5f990c)

3. 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.&#x20;

---

# Source: https://jam.dev/docs/debug-a-jam/devtools/network-req-resp-bodies.md

# Network req/resp bodies

Jam captures request and response bodies for all XHR and fetch requests, but there are a couple of exceptions where you will find XHR/fetch requests for which Jam was not able to capture the request/response body content:

* **Timing:** If the request happened before Jam was initialized on the page. This happens depending on when scripts are loaded in your application vs when Jam's scripts are loaded by your browser.
* **CORS issue:** If the browser performed a preflighted OPTIONS check for this request, which did not pass, then we have a request body that was never sent.
* **Static assets:** images, scripts, and other non-programmatic assets (i.e., not XHR/fetch/websockets) are not captured by Jam.

---

# Source: https://jam.dev/docs/integrations/notion.md

# Notion

{% embed url="<https://www.youtube.com/watch?v=aBuxJLUugT0>" %}

You can connect Notion and Jam in order to instantly create Notion tasks right from Jam's browser extension. Every Notion task you create with Jam automatically includes:

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

That way, it's perfect for engineers to help them debug issues faster.

You can configure all your Notion database properties right from Jam. Our goal is to make you 20x faster at logging bugs to Notion.

## How to use Jam + Notion

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

{% content-ref url="../get-started/getting-started" %}
[getting-started](https://jam.dev/docs/get-started/getting-started)
{% endcontent-ref %}

2. Next, capture your bug with Jam.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fuhzzmcmkf2yu09K7zvDq%2FNotion-1.gif?alt=media&#x26;token=60e41583-a578-4cce-b6df-d8e802d8a7f9" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to Notion.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvmbEDNGkd91wtrL8XCgg%2FNotion-2.gif?alt=media&#x26;token=6fc3d8d2-e4ae-4b68-a9b6-568edfefbff3" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Notion.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FaXxXruleGZ4cnbSVF4gl%2FNotion-3.gif?alt=media&#x26;token=7a34fd3e-b289-416d-ad12-ea22876eca52" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Notion, you will be able to setup your Notion task right from Jam. First search for the database you need and populate all the custom properties right from Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FwCmwYmGMEqBPxHslRQuE%2FNotion-4.gif?alt=media&#x26;token=7686d065-af37-49cb-9409-b0fbe0fa8087" alt="" width="375"><figcaption></figcaption></figure></div>
6. Pro tip: you can click "Edit fields" to manage which properties from Notion are shown in Jam:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FcyMP0HCGb1QGON4v7Zbv%2FNotion-5.gif?alt=media&#x26;token=1c96d108-c69a-47ce-9759-b59cb2d60ea9" alt="" width="375"><figcaption></figcaption></figure></div>
7. Click "Create page" and once Jam creates your Notion page, it will automatically open in a new tab.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvOZ2PNp70WD4IVU3BPvU%2FNotion-6.gif?alt=media&#x26;token=60f692d1-72be-4d96-84ae-5c8ff18d0175" alt="" width="375"><figcaption></figcaption></figure></div>

## How to send existing Jams to Notion

You can automatically create Notion tasks from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to convert to a Notion task.
2. Click "Send to App" and select Notion.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FmyOgrW5JT9L3nZHGA6FZ%2FNotion-7.gif?alt=media&#x26;token=eb54f0c5-c8ec-4e0b-a792-cc550f40dc99" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Notion before, it will first redirect you to log in with Notion.
4. Enter the properties of your Notion database:<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FG3s4mLR91Ug4iDz2PWuF%2FNotion-8.gif?alt=media&#x26;token=540d938e-cbe1-42c8-81cb-7b881d927054" alt="" width="375"><figcaption></figcaption></figure></div>
5. Pro tip: you can click "Edit fields" to manage which properties from Notion are shown in Jam.
6. Click "Create page" to create your Notion task.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJzXfMCbeZrqBrSrrrJjr%2FNotion-9.gif?alt=media&#x26;token=20ae202d-4051-4ade-a7b7-4542ce44cf39" alt="" width="375"><figcaption></figcaption></figure></div>

---

# Source: https://jam.dev/docs/record-a-jam/instant-replay/performance.md

# Performance

Instant Replay works by taking periodic HTML snapshots of the DOM (Document Object Model). These snapshots are then stored in your browser's local storage until you create a Jam, at which point they can be used to generate a video demonstrating the bug in question.

While the Instant Replay feature is incredibly useful, if used on heavier websites, could eat up browser memory storing the HTML snapshots and have a noticeable impact on browser performance. That's why we've spent a lot of time putting safeguards in place so that it has no impact on your browser performance.

Jam automatically disables Instant Replay on particularly heavy websites, such as those with numerous animations or those that re-render large volumes of data at high frequencies (e.g., crypto price websites or spreadsheet applications). This precautionary measure prevents potential performance degradation caused by frequent DOM snapshotting.

## How to override Jam's auto-disabling of Instant Replay on your website

As described above, Jam automatically disables the Instant Replay feature on particularly heavy websites as a precautionary measure to ensure no impact on browser performance.

However, users have the option to override this disabling on any website. For example, if you are using a powerful device with robust processing capabilities, you may not experience any performance issues and may wish to enable Instant Replay for capturing bugs on heavy websites.

To override Jam's cautious disabling of Instant Replay, simply adjust the settings within the Jam extension. If you later decide to revert this decision, you can remove the website from the override list in the extension settings.

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F5XtZA2WmBjDzvnLeojKp%2Fenable-ir.gif?alt=media\&token=7c71805e-2083-4941-b7ed-dbcb4ea316c9)

---

# Source: https://jam.dev/docs/record-a-jam/instant-replay/privacy.md

# Privacy

## How does Instant Replay work?

Instant Replay keeps track of HTML changes in the website you are on, by periodically snapshotting the DOM.

The snapshots are stored locally on your computer until you create a Jam. At that point, Jam stitches together the DOM snapshots to look like a video (but if you inspect it, you'll find it's just replaying HTML inside an iframe).

It's actually not a video recording - just HTML. That way, Jam Instant Replay is not recording a video of your screen, just keeping track of the HTML changes of webpages and then re-rendering the HTML to create a "video". This is just like how the browser saves a snapshot of web pages you visit in local storage so they are faster to open if you visit them again. So there's no video recording even locally on your computer.

## How does Instant Replay preserve my privacy?

Instant Replay is built for privacy first - everything is done locally on your computer, nothing leaves unless you explicitly share it, and the local buffer is permanently deleted every 120 seconds.&#x20;

The snapshots are stored on your computer in your browser's local storage until you create a Jam. Only once you explicitly click "Create" and create a Jam, the snapshots are uploaded to our infrastructure so that you can share your rewind as a link or ticket. All of the snapshots and computing is done offline, locally in your computer browser’s local storage, until you explicitly choose to share.

## How to disable Instant Replay

You can remove Instant Replay from Jam anytime from the extension settings:

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fw8K5HLo7JSXdLcx8BRqW%2Fdisable-ir.gif?alt=media\&token=0336e48d-d8da-4a1c-9b42-8a9b0d681de6)

You can also turn off Instant Replay for specific websites:

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FNRdIPObyTR4MMrb81a23%2Fdisable-ir-site.gif?alt=media\&token=c46198f9-e13a-473c-a84e-f0c816bf4f44)

---

# Source: https://jam.dev/docs/jam-for-customer-support/recording-links.md

# Recording Links

{% embed url="<https://www.youtube.com/watch?v=GP0SBqWU-58>" %}

### How It Works

1. **Generate a recording link** from your [Jam dashboard](https://jam.dev/s/recording-links)
2. **Share via email, chat, or a customer support system like Zendesk, Hubspot, or Intercom**
3. **Recipients click and record** directly in their browser
4. **Recordings appear in your dashboard** with full technical context

Works on any device, no downloads required.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FO9HYGBHjXTpQpwUrlYrX%2FDemo_GIF_Recording_Links.gif?alt=media&#x26;token=77f1f2a9-bc54-4e02-a544-1b63a3970ca2" alt=""><figcaption></figcaption></figure>

### 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 only happen in particular setups

### Next steps

{% content-ref url="send-recording-links-from-your-own-domain-and-collect-console-logs" %}
[send-recording-links-from-your-own-domain-and-collect-console-logs](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs)
{% endcontent-ref %}

{% content-ref url="recording-links/how-to-use-recording-links" %}
[how-to-use-recording-links](https://jam.dev/docs/jam-for-customer-support/recording-links/how-to-use-recording-links)
{% endcontent-ref %}

---

# Source: https://jam.dev/docs/guides/tutorials/run-jam-on-local-files.md

# Run Jam on Local Files

You can now use Jam to share feedback with annotations on any file type, JPG, PDF, HTML, etc - just open it in your browser and start Jamming.&#x20;

To get started, all you have to do is enable file access from your browser’s extension settings.

1. Enter "chrome://extensions" in your URL bar and hit enter. This will take you to a page that will show you all the chrome extensions that are installed on your browser.
2. Click on the 'Details' button for the Jam chrome extension.\
   ![](https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2F9LOTGgKeLI4x5nStqtWc%2Fimage.png?alt=media\&token=730768d2-b381-4cda-a367-a38b8ad806d6)
3. Under the section 'Allow access to file URLs', click on the toggle to enable the setting<br>

   <div align="left"><figure><img src="https://1301043760-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2uHTnjhJbqxe3DyUE8c0%2Fuploads%2FhdnVrW385oB3nMPcCD2k%2Fimage.png?alt=media&#x26;token=0faa63d1-a4e8-4c87-b1da-d6f146a5745f" alt="" width="540"><figcaption></figcaption></figure></div>

---

# Source: https://jam.dev/docs/record-a-jam/screenshot/screenshot-hover-states.md

# Screenshot hover states

Here’s how to quickly screenshot a hover state with Jam’s screenshot tool:

1. Open up the Jam browser extension. Find the arrow next to the Capture screenshot option, and click on it. This will reveal additional screenshot options.
2. Choose either a 3-second or 6-second delay. This delay allows you time to set up your hover state before Jam captures the screenshot.
3. Drag an area of the screen to take a cropped screenshot or click to take a full page screenshot. Once you let go of the mouse, the delay timer will start counting down.
4. During the countdown, hover over the element. Position your cursor over the desired UI element and maintain the hover state during the countdown.
5. Once the delay countdown ends, Jam automatically captures the screenshot including the hover state.
6. After the screenshot has been captured, you can use Jam's suite of annotation tools to add drawings, shapes, arrows, or text to the image.
7. Click "Create" to generate a shareable link. Jam will automatically package the screenshot along with relevant diagnostic data into a well-structured bug report and copy the link to your clipboard.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FH236ds96VJ3xWACJljib%2Fhover.gif?alt=media&#x26;token=c0e72b83-7a90-4c0e-a7e1-68d1537828e9" alt=""><figcaption></figcaption></figure>

---

# Source: https://jam.dev/docs/record-a-jam/screenshot.md

# Screenshot

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 to aid in capturing bugs while automatically including all the technical details engineers require to address and fix them.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F9dEkzINSonblJTgOmYlN%2Fscreenshot.gif?alt=media&#x26;token=f9b153d1-e219-45de-a747-2822775c61df" alt=""><figcaption></figcaption></figure>

## Automated technical diagnostic collection

When you capture a screenshot with Jam, Jam captures the following technical diagnostics and auto-includes them to help your engineers debug faster:

* Console logs
* Fully inspectable network requests
* URL
* Timestamp and country
* Device, OS, Browser
* Viewport size
* Network speed
* Full page context of your cropped screenshot

And packages it all into one easy link to be shared with an engineer or pasted into a ticket.

## Click to capture a full screenshot.&#x20;

Click once on the page to take a full screen screenshot of the viewport.

Here's an example of taking a full screenshot by clicking once on the page:

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FHokiGW797SrR276uJIyY%2Ffullscreenshot.gif?alt=media\&token=6bfed798-d34d-4046-ba0d-05f13deaf50d)

## Drag to crop a screenshot.

Drag an area of the screen to take a cropped screenshot of that area.

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FonwF7kfz7QM5JVghzwcG%2Fcropped-screenshot.gif?alt=media\&token=64735efa-17cf-4699-82f9-6f6f63361776)

When you take a cropped screenshot with Jam, it also captures a full screen shot. This full screenshot will be side by side with the cropped screenshot in the Jam shared with engineers. This helps engineers see where the cropped image came from.&#x20;

If you don't want the full screenshot included, you can deselect this option in the Jam draft window before you hit 'Create'.

## Screenshot annotations

Once a screenshot is captured, you can annotate your screenshots, using various annotation tools such as drawing, shapes, arrows, and text.

---

# Source: https://jam.dev/docs/debug-a-jam/devtools/secrets.md

# Secrets

## Why do I see "JAM\_DOES\_NOT\_SAVE\_SECRETS"?

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJYzZ1hAtytaPtjEDPltO%2FScreenshot%202023-07-07%20at%209.36.58%20PM.png?alt=media&#x26;token=27b8ba5d-ca8a-4afd-852a-e3180453ab6f" alt=""><figcaption></figcaption></figure>

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.&#x20;

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. Please help us improve our filtering accuracy by sending your feedback to <hello@jam.dev>.

---

# Source: https://jam.dev/docs/company/security-privacy-and-compliance-policy.md

# Security, Privacy and Compliance Policy

Jam’s data privacy and security practices adhere to rigorous enterprise standards. Our infrastructure, data policies and internal corporate processes have been run through extensive security tests by third-party auditors.&#x20;

Our security policies are supported by quarterly vulnerability tests, and annual exercises as dictated by SOC 2 Type 2 requirements.

Read more about Jam's security practices and compliance measures below.

## Privacy & Data Protection

### Where are Jam recordings stored?

Jam stores all recordings with Google Cloud Platform. Today, we are not able to redirect Jams to your chosen storage solution.

### Can we choose when Jam recordings are to be deleted?

Yes, Jam customers can specify a data deletion schedule for their workspace. Please contact us to implement your chosen schedule.

### Who has access to Jam recordings?

Jam provides [Access Controls](https://jam.dev/docs/administration/access-controls) so that you can control who can view your Jams. You can set global permissions so that only people with verified access to an email address with your company domain can view Jams. You can further narrow access to specific email addresses on a per Jam basis.

### How does Jam gather consent from end customers?

An end customer must proactively choose to begin recording and to submit their recording before any visual and browser data is stored by Jam. Both steps are forms of consent that the end user can decline at their discretion.

### How does Jam minimize the amount of sensitive information it collects?

Jam gathers visual screen recordings and data directly from the user’s browser. We also collect audio if the user opts into recording their voice alongside their screen. Jam has put protective measures in place to ensure users do not share or expose unnecessary sensitive data. Please refer to the following resources for deeper details:

* **Jam obfuscates sensitive data from network requests -** [learn more](https://jam.dev/docs/debug-a-jam/devtools/secrets)
* **Jam automatically blurs screen recordings** - [learn more](https://jam.dev/docs/jam-for-customer-support/advanced-data-protection-for-customer-support-jams-auto-blur)

### Can we tailor the automatic blurring feature to our business?

Yes, Jam gives our customers control over what data elements will be automatically blurred during recordings. [In this guide](https://jam.dev/docs/jam-for-customer-support/advanced-data-protection-for-customer-support-jams-auto-blur), we outline the data elements that are included in Jam’s default settings. It also includes instructions for how to choose data elements based on your own product context.

## Infrastructure & Data Management

### Infrastructure

Jam uses Google Cloud Platform as the cloud provider to store data. For GCP, we use the Central US region. Jam uses Cloudflare for CDN. The Chrome extension is distributed through Google’s Chrome app store.

### Does Jam backup data?

Yes. Our data retention period depends on the frequency of the snapshots.

#### Frequency Retention period

| Frequency | Retention period |
| --------- | ---------------- |
| Hourly    | 2 days           |
| Daily     | 7 days           |
| Weekly    | 4 weeks          |
| Monthly   | 12 months        |

## Security Measures

### Encryption

Yes. Data is encrypted at rest (AES-256) and in transit (HTTPS/TLS).

### Securing our cloud environment

Access to our cloud services, source code, third-party tools etc. are secured with 2FA.

### What are Jam’s practices for reacting to security incidents?

We take security very seriously. We review security issues as soon as we learn about them. We let our users know if they are affected by any security incident.

### Has Jam deployed firewalls and intrusion detection and prevention systems in your environment?

Jam uses Cloudflare as a mechanism to prevent attacks on our environment, as well as have firewalls and controls within our GCP project. However it does not have an IDS or IPS running in our production network because the network is fully operated by GCP.

### How often is Jam performing vulnerability scans and penetration tests on your own infrastructure?

Jam is using GitHub to store our source code. GitHub provides a vulnerability feed of issues that become known in third party software dependencies used by our source code.

## Compliance & Certifications

### SOC 2 Type 2 Compliance

Jam is SOC 2 Type 2 compliant. We are happy to share our SOC 2 Type 2 report with qualified customers. You can email <security@jam.dev> to request the report.

## Contact

### Who should I reach out to if I have a security question about Jam?

If you notice a security issue or have a question or concern, you can reach out to us at <security@jam.dev> and we'll respond as soon as possible. Currently, Jam does not have a bug bounty program.

<br>

---

# Source: https://jam.dev/docs/administration/security.md

# Security

### Overview

Jam's security infrastructure meets enterprise standards with SOC 2 Type II compliance, end-to-end encryption, and robust cloud protection. Your data stays secure while your team stays productive.

### Security Certifications

Jam is compliant with **SOC 2 Type II** with annual audits and quarterly vulnerability assessments.&#x20;

| Security Certification | Status                         |
| ---------------------- | ------------------------------ |
| **SOC 2 Type II**      | :white\_check\_mark: Compliant |
| **GDPR**               | :white\_check\_mark: Compliant |
| **HIPPA**              | `Soon`                         |

### Enterprise Security Features

{% hint style="info" %}
Available to workspaces on our [Enterprise](https://jam.dev/pricing) plans.
{% endhint %}

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Single Sign-On</strong></td><td>Connect Jam with your existing identity provider for seamless authentication.</td><td><a href="sso">sso</a></td></tr><tr><td><strong>Audit Logs</strong></td><td>Monitor key workspace activities with comprehensive audit logs.</td><td><a href="audit-logs">audit-logs</a></td></tr><tr><td><strong>Custom Data Retention</strong></td><td>Control how long Jams stay in your workspace with custom deletion schedules.</td><td></td></tr><tr><td><strong>Access Controls</strong></td><td>Control default access for all existing and new Jams created by your team</td><td><a href="access-controls">access-controls</a></td></tr></tbody></table>

#### Enable Enterprise Security Features

Contact our sales team to upgrade to Enterprise. Work with our team to configure SSO, audit logs, and retention policies. Begin using enhanced security features immediately after setup

<a href="https://jam.dev/contact-sales" class="button primary">Contact</a>

### Security Monitoring

#### Request SOC 2 Report

Email <security@jam.dev> with your request\
Include your company information and intended use. Our team will verify your qualifications and provide the report.

#### Report Security Issues

Email <security@jam.dev> with details. \
Our security team responds as quickly as possible. We'll keep you updated throughout the investigation process

### FAQs

<details>

<summary>Where is my data stored?</summary>

All data is stored in Google Cloud Platform's Central US region with Cloudflare providing global CDN services.

</details>

<details>

<summary>How often does Jam perform security testing?</summary>

We conduct quarterly vulnerability scans and annual penetration tests as required by SOC 2 Type II compliance.

</details>

<details>

<summary>Does Jam have intrusion detection systems?</summary>

Jam uses Cloudflare for attack prevention and Google Cloud Platform (GCP) firewalls for infrastructure protection. Since our network is fully managed by GCP, we don't run separate IDS/IPS systems.

</details>

<details>

<summary>Does Jam have a bug bounty program?</summary>

We don't currently offer a bug bounty program, but we welcome security reports at <security@jam.dev> and respond promptly to all submissions.

</details>

---

# Source: https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs.md

# Send Recording Links from your own domain and collect console logs

{% hint style="info" %}
You'll need write permissions to your website to complete these three steps:

1. **Register one or more Recording URLs** with Jam\
   \&#xNAN;*(so we can generate links to your site)*
2. **Set up Jam's Recorder & Capture Scripts** on your site\
   \&#xNAN;*(so your users can start recording & capturing page context)*
3. **Modify your Content-Security-Policy** if necessary\
   \&#xNAN;*(so Jam assets can execute on your page)*
   {% endhint %}

## 1. Register one or more Recording URLs

{% hint style="info" %}
Hosted Recording Links bring users directly to your pages. You may show them content before and after the recording begins. Each base Recording URL must be registered before use.
{% endhint %}

Navigate to your Jam team's settings page, and click the "Recording Links" tab. [Here's a quick link to get there.](https://jam.dev/s/settings/recording-links)

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FPNIrkNM5bnWEGwcyHy4p%2FRecording_Links_Settings_Setup_GIF.gif?alt=media&#x26;token=9145afd7-ff60-4008-89f9-e6c0417edf6b" alt=""><figcaption></figcaption></figure>

Under Recording URLs: add, install, and verify the installation of one or more valid URLs. These will later be available to select when creating a Recording Link.

If your application redirects users from your Recording URL—for example, redirecting unauthorized users to a login page—you will need to persist Jam's querystring parameters through the redirect. Most important is `jam-recording=...`, but all `jam-` parameters should be persisted.

{% hint style="warning" %}
You will need at least one Recording URL for each domain you wish to record on. Recordings have access only to debug data from capture scripts on pages on the same domain that initiated the recording.\
\
In most cases, a recoder installed on the root domain will also be able to capture events from subdomains. The exception is Safari, where events will only be captured if recorder and capture script are on the same subdomain.&#x20;

**For example:** a recorder installed on `example.com/recorder` can see events from pages on `sub.example.com` (and vice-versa) except on Safari.
{% endhint %}

## 2. Set up Jam's Recorder & Capture Scripts

{% hint style="info" %}
To properly associate your users' recordings with the logs we collect, Jam's Recorder and Capture scripts need to be served under the *same origin* \[[MDN](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)] as your site or application.
{% endhint %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FRHAmQjgqe5mSJuuwhjjs%2FRecording_Links_Team_ID_GIF.gif?alt=media&#x26;token=03634380-f754-45c4-ae58-92301040064b" alt=""><figcaption></figcaption></figure>

Use Jam.js' Recorder and Capture scripts to initialize a recorder on your page and associate captured events.

```html
<html>
  <head>
    <!-- Lets users record their screen from your site -->
    <meta name="jam:team" content="my-team-id-from-dashboard" />
    <script type="module" src="https://js.jam.dev/recorder.js"></script>

    <!-- Captures user events and developer logs -->
    <script type="module" src="https://js.jam.dev/capture.js"></script>
  </head>
</html>
```

The Recorder script will cause our Recorder UX to pop up over your page when users open your Recording Links. If the user dismisses the Recorder UX before starting a recording, they must re-click your Recording Link to try again.

The Capture script will capture events—such as console logs, network events, clicks, and keypresses—on your pages when recordings are in progress. These will be associated and saved with your users' recordings, and otherwise ignored.

Once the recording is complete, Jam will confirm that the user would like to discard their recording if they try to close the Recorder UX before the Jam has been submitted.

Once the Jam has been submitted, the Recorder UX will close automatically, restoring control to your page.

{% hint style="success" %}
To verify this is working: create a Recording Link, then navigate to it. Does the Recorder UX pop up?\
\&#xNAN;*(For not-yet-deployed sites, you must replace the Recording Link URL's host with your localhost equivalent)*
{% endhint %}

We aggressively cache Jam.js assets to minimize load time—especially the Capture script!—prioritizing only critical code and deferring the rest to ensure your page continues to load and run rapidly.

{% hint style="warning" %}
Note: Jam.js' Capture script can only capture console and network requests made after it initializes.

The `<script>` tag should be placed as early as possible on the page, and should only use a lazy-loaded `import` when explicitly trading accuracy for un-cached load performance (e.g. on SEO-optimized pages).
{% endhint %}

## 3. Modify your Content-Security-Policy

*(If your site does not specify CSP directives, you can skip this step.)*

Some sites specify Content-Security-Policy \[[MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)] directives via either a header or meta tag. A `frame-src` or `script-src` directive that doesn't include `*.jam.dev` will block Jam.js from including console logs with your user's Jams.

To fix this, modify your CSP header or meta tag to allow `*.jam.dev` as both. For example:

```
<meta
  http-equiv="Content-Security-Policy"
  content="frame-src 'self' *.jam.dev; script-src 'self' *.jam.dev;"
/>
```

## Verify logs are captured

Congratulations! You should now be able to capture logs on your domain. To verify your install is working correctly, simply click the Verify link in your Recording URL settings:

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FSeOf4D2aZ7kkvA6ulQru%2FRecording_Links_Verify_GIF.gif?alt=media&#x26;token=bc802795-d5db-4d3a-8d7d-7cc15cec8b6a" alt=""><figcaption></figcaption></figure>

This will open your Recording URL to a special "verify" UI. If you see this, it means you've successfully installed the Recorder script. If you have a tab open with the Capture tab successfully installed on it, the test will succeed; otherwise you'll have to open a tab to such a page or revisit that installation step.

{% hint style="warning" %}
If you are testing not-yet-deployed code, try replacing the URL we open with your localhost equivalent
{% endhint %}

{% hint style="info" %}
If your code calls `window.jam.recorder.open(...)` manually, simply provide "verify" as the `recordingId`.
{% endhint %}

## **Jam.Metadata**

With one additional function call, `jam.metadata()`, you can ensure that every Jam submitted from your website includes the metadata you need to debug the bug. You can log anything in Jam.Metadata: simple static values like User ID, to any data like redux or react state. Whatever you need to debug, just send it to Jam.Metadata so it's always there for you in any ticket. More information can be found [here](https://jam.dev/docs/debug-a-jam/devtools/jam.metadata).

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F9Fd2qIxw5wGWUoaevn85%2Fimage.png?alt=media&#x26;token=67f16468-3c13-4485-a5f5-62bc1bb8f0bc" alt=""><figcaption></figcaption></figure>

## FAQs

* **Q: Can I put the Recorder and Capture scripts on different pages?**\
  A: Yes! There is no danger in doing so. If you do, the `<meta name="jam:team" ...>` element must be included on pages with the recorder script, and may be omitted from ones with only the capture script.
* **Q: Can I programmatically create Recording Links directly on my page?**\
  A: Not at this time; an upcoming release will expose an API you can use to create Recording Links from anywhere—Slack, Zendesk, or directly on your site (or app).
* **Q: Can I customize the Recorder UI?**\
  A: Not at this time—but we'd like to make this more customizable. Please let us know what you'd like to do!
* **Q: Can I associate Jam data with recordings we manage?**\
  A: No; due to browser storage + message partitioning controls, Jam's Recording Links scripts only work when used together.

## **Current limitations**

* Log capture is fully-supported in Chrome (including Incognito Windows) and Firefox (including Private Windows), and supported in most Safari windows. Log capture from Safari Private Windows is not currently supported.
* If the Capture script is installed within an iframe, the top level logs will not get captured, e.g. capturing logs in embedded Shopify apps.
* When using the `async` and `defer` script attributes or lazy-loaded `import(...)` calls with Jam's Capture script, we cannot guarantee it will run early enough to capture *every* console log, network request, or other capturable event.

---

# Source: https://jam.dev/docs/integrations/sentry.md

# Sentry

{% embed url="<https://youtu.be/S0gU8csDb4Q>" %}

You can connect Sentry and Jam in order to view your Sentry logs right from Jam. This gives you easy visibility of the bug from the frontend (captured with Jam) to all the other services across your infrastructure that the bug traces across (captured with Sentry).

The goal: make it much faster for engineers to find the issue causing any reported bug by pairing Jam + Sentry together.&#x20;

## How to get started and connect Jam & Sentry

1. Jam will detect if Sentry is installed on a website, and show a Sentry tab if Sentry is detected. Click on that tab to be guided through authenticating with Sentry.\
   ![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FGM27A0SjXL3q35mIBTIb%2FScreenshot%202023-07-03%20at%2011.37.52%20AM%20\(1\).png?alt=media\&token=d26f9e80-0ebd-4657-a8af-9f80e720381c)
2. You will be prompted to connect Sentry. Click on the button and go through the Sentry OAuth flow to connect Jam to Sentry.\
   ![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FifrOpWGzx4LKziAuwGXS%2FScreenshot%202023-07-03%20at%201.49.10%20PM%20\(1\).png?alt=media\&token=9a102408-72d2-4120-a322-5595c4471709)
3. If Sentry is not installed on the website, have no fear, there is another way to connect! Go to your Jam workspace settings, click on "Connected Apps", and connect to Sentry from there. \
   ![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fqo7l4h9PueLMstN542Xu%2FScreenshot%202023-08-02%20at%2018.40.47.png?alt=media\&token=07482cb0-d7cf-4d91-ba7b-886997cb9ca2)
4. Done! Now you can view Sentry events right from Jam.&#x20;

Now you will be able to see Sentry events from the same timestamp of the Jam right in the Jam.&#x20;

If you are on a Sentry business plan, you will be able to see events across all your Sentry projects. If you are on a lower Sentry tier, you will only be able to choose 1 project to view logs from at a time.&#x20;

You can scope the logs by timestamp, and filter by specific keywords to find relevant Sentry events. Click on any Sentry event listed in Jam to open up that log in Sentry.

## How are Sentry logs chosen to be surfaced in Jam?

Jam's goal is to show engineers relevant logs from Sentry right in Jam.&#x20;

Jam filters Sentry logs displayed in Jam by timestamp. By default, Jam will display Sentry logs from the 5 minutes before and after the Jam was created.

By default, Jam will filter the logs you see by the detected environment field sent to Sentry from the frontend. For example, if the client web application sends events to Sentry with the environment field "staging", then Sentry logs shown in the Jam will be default scoped to show "environment:staging".

![](https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FTibTVqrpJ5NjwDHedseM%2Fimage%20\(13\).png?alt=media\&token=c02847a7-7911-4d0f-a127-a1b78c17f742)

Our goal is to over time, be able to show you only the most relevant Sentry logs so that we help you quickly and easily trace bugs across your infrastructure. We'd love to hear how you've instrumented Sentry such that we can find the proper Sentry logs for any bug. Please reach out with any feedback to <hello@jam.dev>.

## Which plan includes the Sentry integration?

Integrating with Sentry is a team plan only feature in Jam. You can learn more about our pricing here: [jam.dev/pricing](https://jam.dev/pricing).

---

# Source: https://jam.dev/docs/jam-for-customer-support/servicenow.md

# ServiceNow

1. Create a new Recording Link from the Jam browser extension
2. Copy & Paste the customer conversation URL in the Recording Link description (e.g. <https://yourcompany.freshdesk.com/agent/tickets/125324>
3. Share the Recording Link in the customer conversation
4. When the recording is ready, you will receive an email with the customer recording with a reference to the corresponding customer conversation

{% hint style="info" %}
If you want to capture logs and network requests from your Recording Links, follow this [set up guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs).
{% endhint %}

---

# Source: https://jam.dev/docs/guides/set-up-a-macos-shortcut-to-request-customer-jams-from-anywhere.md

# Source: https://jam.dev/docs/jam-for-customer-support/set-up-a-macos-shortcut-to-request-customer-jams-from-anywhere.md

# Set up a macOS shortcut to request Customer Jams from anywhere

1\. Generate a recording link (with the Jam extension or from the dashboard) and name it “General feedback” or whatever you like. Copy the link

2\. Go to System Settings -> Keyboard -> Text Replacements.

3\. Click the "+" button to add a new replacement.

Enter the text you want to replace “/jam” in the "Replace" field and paste the link in the text in the "With" field.

{% hint style="info" %}
You can choose the title of the Jam that is created from your link by adding `?jam-title=` to the query string that you paste in. When you use your shortcut, you can add the desired title of the resulting Jam.<br>

For example, if you want the title of the Jam to be "Shopping cart bug": \
\
`https://recorder.jam.dev/QrBnf3s?jam-title=Shopping+cart+bug`
{% endhint %}

4\. Click "Add" and then "Done".

---

# Source: https://jam.dev/docs/record-a-jam/jam-for-ios/setting-up-logging-in-ios.md

# Setting up logging in iOS

The [JamLog](https://github.com/jamdotdev/jam-ios-log) framework lets you send log events to [Jam for iOS](https://apps.apple.com/us/app/jam-fix-bugs-faster/id6469037234) so that they can be associated with your [Jam](https://jam.dev).

### Supported Platforms

* iOS 15.0+

### Quick Start

Add the following to your `Package.swift`:

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

Alternatively, you can add the package [directly via Xcode](https://developer.apple.com/documentation/xcode/adding_package_dependencies_to_your_app).

### Usage

```swift
import Jam

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

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

### SwiftLog

You can integrate with [SwiftLog](https://github.com/apple/swift-log) by importing `JamSwiftLog` and bootstraping the logging system:

```swift
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`. Assuming you are already using the `StreamLogHandler`:

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

---

# Source: https://jam.dev/docs/integrations/slack.md

# Slack

{% embed url="<https://youtu.be/Qsa3mIj8dyM>" %}

You can connect Slack and Jam in order to instantly send your bug reports to Slack right from Jam's browser extension.&#x20;

Every Slack message you create with Jam automatically includes:

* Screen capture (screenshot, video or instant session replay)
* Console logs&#x20;
* Fully inspectable network requests&#x20;
* URL Timestamp and country&#x20;
* Device, OS, Browser&#x20;
* Viewport size&#x20;
* Network speed&#x20;

That way, it's perfect for engineers to help them debug issues faster – right from Slack.

## How to use Jam + Slack to report bugs in Slack

1. First, you'll need to make sure you have Jam installed in your browser. Follow our Jam getting started guide here if you haven't downloaded and setup Jam yet:

{% content-ref url="../get-started/getting-started" %}
[getting-started](https://jam.dev/docs/get-started/getting-started)
{% endcontent-ref %}

2. Next, capture your bug with Jam. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FnzDivWSL1gDOAQs312vN%2Fslack-1.gif?alt=media&#x26;token=0d76809d-cca1-4768-a43f-6e4a50dfd435" alt="" width="375"><figcaption></figcaption></figure></div>
3. In the Jam extension, you will have the option to choose where Jam sends your screen capture to. Click on "Link you can share" and change it to Slack.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Ftlb58AEGhxbsfmUhDjiD%2Fslack-select.gif?alt=media&#x26;token=0631b255-c995-424a-82e7-a150a6d0f8f4" alt="" width="375"><figcaption></figcaption></figure></div>
4. Jam will guide you through authenticating with Slack.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FpUscAtlB9h1aehPAZY5A%2Fslack-auth.gif?alt=media&#x26;token=be6e7c56-b7cb-4ff5-9a29-ac4870d5de11" alt="" width="375"><figcaption></figcaption></figure></div>
5. Once Jam is connected to Slack, you will be able to send Jams to your Slack right from Jam.\
   Choose which channel (private, public or specific user) to send the Jam to. You can only access conversations that you are part of. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FOYBGIowwgwRRtixoFYU6%2Fslack-3.gif?alt=media&#x26;token=13e821b8-7ed0-4578-9d2f-b7479359118d" alt="" width="375"><figcaption></figcaption></figure></div>
6. Click "Send message" and once Jam creates your Slack message, the created Jam will automatically open in a new tab, and will be sent to the Slack channel requested! <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F1gUxcdr7sMIi0HPejCEP%2Fslack-4.gif?alt=media&#x26;token=cb87abc1-f7b9-497d-9840-eb6e5da0aec1" alt="" width="375"><figcaption></figcaption></figure></div>

All done! Open up Slack to see your newly created Jam. It will format perfectly for engineers – whether it's a screenshot:

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FFfCnJmngCfqQckSwMGgb%2Fimage.png?alt=media&#x26;token=66063880-6529-42e5-9685-b9b9ae4787bc" alt="" width="485"><figcaption></figcaption></figure></div>

Or video/instant replay:

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FvMYVwIj5gFewpQlFofEU%2Fimage.png?alt=media&#x26;token=b566a987-fa5d-4cc6-a2b9-514cca2e1b9b" alt="" width="490"><figcaption></figcaption></figure></div>

*^ Engineers can see the web application errors captured with Jam on the video and instant replay timelines right from Slack! Hooray!*

## How to send existing Jams to Slack

You can automatically create Slack messages from existing Jams – in just 2 clicks.

*Note: You must be logged into Jam to use this feature. Logged out users will not see this option.*

1. Open up the Jam you want to share as a Slack message.
2. Click "Send to App" and select Slack.<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FgcJULj9OVTlUIJSpPVgT%2Fslack-tools-1.gif?alt=media&#x26;token=275b1e22-bd68-433b-81ab-df2c62593277" alt="" width="375"><figcaption></figcaption></figure></div>
3. If you have not used Jam + Slack before, it will first redirect you to log in with Slack.
4. Choose which channel (private, public or specific user) to send the Jam to. <br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FyIFGpqlONzuZk39NWtgi%2Fslack-tools-2.gif?alt=media&#x26;token=03fefbfa-8812-4a6d-a448-3e27de1ec800" alt="" width="375"><figcaption></figcaption></figure></div>
5. Click "Send message" to create your Slack message.&#x20;

## How to paste Jams as Slack messages and get inline Jam previews

Once you've connected your Jam account to Slack, every time you share a Jam in Slack, it will show an expanded preview, designed to help engineers get relevant debug info and start fixing bugs without even having to open a link.

To connect your Jam account to Slack:

1. Open the Jam dashboard
2. Go to your account settings or to your team settings. Click on "Connected Apps"<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6LfyMoixZC7YTyy6Bif4%2Fslack-connect-1.gif?alt=media&#x26;token=129ea5de-7243-48af-b736-1d79e73d7d49" alt="" width="375"><figcaption></figcaption></figure></div>
3. Connect Slack<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FVfIIQrhwrBb1pYqaeq0Q%2Fslack-connect-2.gif?alt=media&#x26;token=90bc2c72-597e-49c7-b01c-9965a1b81e65" alt="" width="375"><figcaption></figcaption></figure></div>

---

# Source: https://jam.dev/docs/administration/sso.md

# SSO

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FAQ01ub0ovCISyFzEW9mY%2FSetting_%20SSO.png?alt=media&#x26;token=2b005be2-d949-439b-aa0c-75e7c4de63cf" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Available to workspaces on our [Enterprise](https://jam.dev/pricing) plans.
{% endhint %}

### Overview

Connect your identity provider to Jam for streamlined authentication and automated team management. Your team gets secure, centralized access control while you eliminate manual user provisioning overhead.

### How It Works

**SSO (Single Sign-On):** Connects your identity provider to Jam for authentication. Team members log in using their corporate credentials instead of separate Jam passwords.

**Directory Sync:** Automatically syncs user changes from your identity provider to Jam. When you add, remove, or modify users in your IdP, those changes reflect in your Jam workspace automatically.<br>

### Configure

{% tabs %}
{% tab title="SSO Setup" %}
**Configure Single Sign-On**

1. Go to Team Settings → General → Access
2. Click Setup next to Identity Provider
3. Follow the step-by-step walkthrough for your IdP
4. Complete the configuration in your identity provider

You should now see your IdP listed in the Access section. Team members can log in using SSO.

{% hint style="warning" %}
SSO is configured for a single domain by default. Need multiple domains? [Contact](https://jam.dev/help) our team to enable additional domains.
{% endhint %}
{% endtab %}

{% tab title="Directory Sync Setup" %}
**Configure Directory Sync**

1. Go to Team Settings → General → Access
2. Click Setup next to Active Directory
3. Follow the step-by-step walkthrough for your IdP
4. Select which user groups to sync (optional)

You should now see your IdP listed in the Access section. New users added to your IdP will automatically join your Jam team.

{% hint style="info" %}
Provisioned users get the Creator role by default. You'll need to adjust roles manually in Jam settings.
{% endhint %}
{% endtab %}
{% endtabs %}

#### User Management

How you manage team members depends on your Directory Sync configuration:

{% tabs %}
{% tab title="With Directory Sync" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FrnmRRd1YEDhVzKTceY3N%2FSetting_%20Directoy%20Sync%20On.png?alt=media&#x26;token=fd7956ad-4d01-4c8c-8a5b-4c5a13cf1800" alt=""><figcaption></figcaption></figure>

**Automated Management**

* User provisioning: Happens in your identity provider
* New user notifications: Users get email notifications when provisioned
* Role management: Handle manually in Jam team settings
* User removal: Remove from IdP to revoke Jam access automatically
* Group sync: Manage access via user groups in your IdP

Access the directory sync management page through Team Settings → Team → Manage Members.

{% hint style="warning" %}
User groups cannot be mapped to specific Jam roles automatically. Role assignment requires manual configuration.
{% endhint %}
{% endtab %}

{% tab title="Without Directory Sync" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FsFSgTIQtIiAFS7pnsSJx%2FSetting_%20Directoy%20Sync%20Off.png?alt=media&#x26;token=90b3452d-1256-47ec-b6e9-a98591c51287" alt=""><figcaption></figcaption></figure>

**Manual Management**

* User provisioning: Add users directly in Jam team settings
* Role management: Assign and modify roles in Jam
* User removal: Remove users manually from team settings

All user management happens within your Jam workspace settings.
{% endtab %}
{% endtabs %}

### FAQs

<details>

<summary>Can I use SSO without Directory Sync?</summary>

Yes. SSO handles authentication while Directory Sync manages user provisioning. You can enable either feature independently.

</details>

<details>

<summary>What identity providers are supported?</summary>

Jam supports all major identity providers including Okta, Azure AD, Google Workspace, and SAML-compatible providers.

</details>

<details>

<summary>Can I map user groups to specific Jam roles?</summary>

Not automatically. While you can sync user groups from your IdP, role assignment in Jam requires manual configuration.

</details>

<details>

<summary>What happens when I remove a user from my identity provider?</summary>

With Directory Sync enabled, users automatically lose access to their Jam account when removed from your IdP.

</details>

---

# Source: https://jam.dev/docs/guides/tutorials/suppress-jam-logs-in-devtools.md

# Suppress Jam Logs in DevTools

If you’re a web developer using Jam, you may want to reset the file names you see in your console logs while developing. It’s unfortunately not possible from our end, but it is possible from yours. 😅

Here is how you can add Jam’s scripts to an ignore list, reseting the file names you see in the console:

What you will need to do is add Jam’s `jam-console-devtools.js` script to your ignore list. You can follow these instructions to do so on this page: [https://developer.chrome.com/docs/devtools/javascript/reference/#call-stack-ignore-list](https://developer.chrome.com/docs/devtools/javascript/reference/?ref=jam-documentation.ghost.io#call-stack-ignore-list)

Or, watch this video (instead of consolePlugin.ts it should be `jam-extension-console-proxy.js`):

{% embed url="<https://youtube.com/shorts/e-w8UtlG0iQ>" %}

---

# Source: https://jam.dev/docs/get-started/team-setup-and-integrations.md

# Team Setup and Integrations

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fu6dqbhVOhLZzpildW5i0%2Fimage.png?alt=media&#x26;token=066c5d0a-b87c-435f-b37e-915bdeabcb15" alt=""><figcaption></figcaption></figure>

### Key Benefits

* **All Jams in one place:** Avoid duplicate bug reporting with centralized team workspace
* **Access control:** Set domain-based permissions or per-Jam sharing
* **Cost-effective scaling:** Free viewer seats for stakeholders, paid seats for creators
* **Easy onboarding:** Domain-based workspace discovery helps teammates find and join your team

### Invite your team

1. Log in to [jam.dev](https://jam.dev/login)
2. Click **Invite** in the dashboard header
3. Invite team members via email or team invite link&#x20;
4. Optional: modify the team member roles, here's how: [members-and-roles](https://jam.dev/docs/administration/members-and-roles "mention")

### Connect Your Apps

Integrate Jam with your existing workflow:

#### Available Integrations

{% tabs %}
{% tab title="Communication & Issue trackers" %}

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td>Asana</td><td>Create a new Asana task</td><td><a href="../integrations/asana">asana</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F92sOeTffxYofh0WV6hWt%2FAsana.png?alt=media&#x26;token=96ab1876-a08e-488f-888f-49c6b21da4ad">Asana.png</a></td></tr><tr><td>AzureDevOps</td><td>Create a new ticket in AzureDevOps</td><td><a href="../integrations/azure-devops">azure-devops</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FCO8LjMIErvuF6VnC1q3v%2FAzure.png?alt=media&#x26;token=67cb54a4-9a56-42c6-879b-a11700d6c8a5">Azure.png</a></td></tr><tr><td>ClickUp</td><td>Create a new ClickUp task</td><td><a href="../integrations/clickup">clickup</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fm7iNCZwnDdCpJ1oXGvO3%2FClickUp.png?alt=media&#x26;token=9596f4d1-9c61-4d81-b7d0-8d5214187aae">ClickUp.png</a></td></tr><tr><td>GitHub</td><td>Create a new issue in GitLab</td><td><a href="../integrations/github">github</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FM5yjcS4bK5Pupssf0OA7%2FGitHub.png?alt=media&#x26;token=8529105d-c63c-430f-b2d5-7a958f657ff1">GitHub.png</a></td></tr><tr><td>GitLab</td><td>Create a new issue in GitLab</td><td><a href="../integrations/gitlab">gitlab</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FcWcp3fkajvYV8eZTO2q8%2FGitLab.png?alt=media&#x26;token=9c6fe931-8a33-4973-8a4f-ed5c7f124ba4">GitLab.png</a></td></tr><tr><td>Jira</td><td>Create a new ticket in Jira</td><td><a href="../integrations/jira">jira</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FSK2Jg7YbHWVBf8MjOpC4%2FJira.png?alt=media&#x26;token=f993aa37-149b-4ac7-aa7e-fc0229ed132e">Jira.png</a></td></tr><tr><td>Linear</td><td>Create a new issue in Linear</td><td><a href="../integrations/linear">linear</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBv5ktR0KEKujWVjZSQYN%2FLinear.png?alt=media&#x26;token=328859c2-2bf3-4936-b7be-ad54a144e6d7">Linear.png</a></td></tr><tr><td>Notion</td><td>Create new page in Notion databases</td><td><a href="../integrations/notion">notion</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FysHUCStNNPnhd3iSiBc4%2FNotion.png?alt=media&#x26;token=4f7e9b0c-40d0-4103-8c69-05b8faf32c1b">Notion.png</a></td></tr><tr><td>Slack</td><td>Send a new message in channel</td><td><a href="../integrations/slack">slack</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FafpVGsJWw7cJhI4BP93D%2FSlack.png?alt=media&#x26;token=c8902d8a-68e5-4be2-a7fe-e248771dd7c1">Slack.png</a></td></tr></tbody></table>
{% endtab %}

{% tab title="Help desks & CRMs" %}

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td>Intercom</td><td>Create Jams directly from intercom customer chats</td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F28QWYqyBpCjoJefTBfZD%2FIntercom.png?alt=media&#x26;token=721b4b0d-6052-44f1-ae19-60e774a6a35c">Intercom.png</a></td><td><a href="broken-reference">Broken link</a></td></tr><tr><td>Zendesk</td><td><code>Coming soon</code></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2Fd5z4AfxrBmVHm6SZupnV%2FZendesk.png?alt=media&#x26;token=6853944f-4583-472b-a3c4-740a10e41b9f">Zendesk.png</a></td><td></td></tr><tr><td>HubSpot</td><td><code>Coming soon</code></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FMhAbKH4ivtfvsHoTdhoC%2FHubSpot.png?alt=media&#x26;token=9d696012-3ff3-4be7-b024-14f693a200bc">HubSpot.png</a></td><td></td></tr></tbody></table>
{% endtab %}

{% tab title="Analytics & Backend" %}

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td>Fullstory</td><td></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FLM75ATljuaGFpXpeQPFr%2FFullstory.png?alt=media&#x26;token=daff06f0-103e-4f9a-bf4a-5370011006ca">Fullstory.png</a></td><td><a href="../integrations/fullstory">fullstory</a></td></tr><tr><td>LogRocket</td><td></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FOkyusiureMH7SgLpvfJu%2FLogRocket.png?alt=media&#x26;token=ef3bff53-8750-4f72-aed1-5a468f7f8a55">LogRocket.png</a></td><td><a href="../integrations/logrocket">logrocket</a></td></tr><tr><td>Sentry</td><td></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FXyLISKZmja8Vlo3L6SdD%2FSentry.png?alt=media&#x26;token=88254969-55f7-4fd6-bd29-b1f723cba9be">Sentry.png</a></td><td><a href="../integrations/sentry">sentry</a></td></tr></tbody></table>
{% endtab %}
{% endtabs %}

#### Setup Process

1. Go to **Settings** in your workspace
2. Select **Integrations**
3. Connect your preferred tools
4. Choose an integration when creating Jams

### Send Jams to Integrations

{% tabs %}
{% tab title="New Jams" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FAmak2XI9jVnLLGGXhW8M%2Fimage.png?alt=media&#x26;token=a131b64b-555d-44d1-b881-1b27af86a190" alt=""><figcaption></figcaption></figure>

\
You can send any new created Jams to integrated tools:

1. Capture a Jam
2. Click the "`link to share`" select menu
3. Select your destination integration
4. Click create to send your Jam to your selected integration
   {% endtab %}

{% tab title="Send Existing Jams" %}

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FVoYaFmi5mrgkEgr5A6qZ%2FSend%20to%20App_%20Jam%20Share%20Page.png?alt=media&#x26;token=fe699a33-80b8-4801-8a14-506e44345744" alt=""><figcaption></figcaption></figure>

You can send previously created Jams to integrated tools:

1. Open any existing Jam
2. Click the `send to app` button
3. Select your destination integration
4. Click create to send your Jam to your integration
   {% endtab %}
   {% endtabs %}

***

---

# Source: https://jam.dev/docs/record-a-jam/video-screen-recording/video-annotations.md

# Video annotations

Easily highlight key details in your video recordings using annotations, and help engineers quickly understand the issue you're reporting.&#x20;

{% hint style="info" %}
The draw feature is available on all [paid plans](https://jam.dev/pricing). You can also try the feature for free 3 times.&#x20;
{% endhint %}

Here's how to draw on your video recording:

1. Select tab or desktop recording from Jam extension
2. While recording is in progress you can select the draw tool and start drawing. \
   Note: Added shapes will automatically fade away after 3 seconds.

<div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FyVd5SBPlfpwgSZwduPZT%2FVideo-annotation.gif?alt=media&#x26;token=b7abe0c6-2594-4249-8264-f23b573eaadb" alt="" width="375"><figcaption></figcaption></figure></div>

{% hint style="info" %}
Video cannot be annotated *after* recording, only during the recording.
{% endhint %}

---

# Source: https://jam.dev/docs/record-a-jam/video-screen-recording/video-blur.md

# Video blur

With blur you can easily hide sensitive information in your video recording, and share your Jams knowing that private details are secure.

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 \
   \&#xNAN;*Note: available for tab recording only*<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F6gLpIPP8VaG6GSN4o21T%2FVideo-blur.gif?alt=media&#x26;token=5250e01d-1822-43ec-a355-352e012d38e9" alt="" width="375"><figcaption></figcaption></figure></div>
3. You can also use blur during recording. Clicking the blur tool will pause the recording, and you can start selecting elements you want to hide. To remove the blur, you can click again on the blurred element. Once you’re done, you can click “Done” button, and continue recording your video.\
   \&#xNAN;*Note: Elements cannot be blurred after the recording, only before or during the recording.*<br>

   <div align="left"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FDzg7K7N0iAdohIlyIDzs%2Fvideo-annotations-unblur.gif?alt=media&#x26;token=4dcb5d45-7ddc-4339-9a0c-63b77b04ffe8" alt="" width="375"><figcaption></figcaption></figure></div>
4. During window recording you can blur elements across multiple tabs

{% hint style="info" %}
The blur feature is available on all [paid plans](https://jam.dev/pricing). You can also try the feature for free 3 times.&#x20;
{% endhint %}

{% hint style="info" %}
Blurring certain page elements like `iframe` and `canvas` is not supported.
{% endhint %}

---

# Source: https://jam.dev/docs/record-a-jam/video-screen-recording.md

# Video Screen Recording

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 to aid in capturing bugs while automatically including all the technical details engineers require to address and fix them.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FO1048cQEYtyOSjBDB48o%2FTab-recording.gif?alt=media&#x26;token=38c17188-c178-497d-9a69-c729a6fa687e" alt=""><figcaption></figcaption></figure>

When you record a video of your screen with Jam, Jam captures the following technical diagnostics and auto-includes them to help your engineers debug faster:

* Console logs
* Fully inspectable network requests
* URL
* Timestamp & country
* Device, OS, Browser
* Viewport size
* Network speed

And packages it all into one easy link to be shared with an engineer or pasted into a ticket.

## Voiceover Recording

When you record a video with Jam, you can optionally choose to record a voiceover for your videos. This helps in providing real-time explanations and context for the activities happening on the screen.

Then you can mute and un-mute your microphone and choose which microphone Jam should use to record your audio.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FSNWQvm5BdQppM30UP2rq%2FMic-controls.gif?alt=media&#x26;token=44ab7be5-9b36-49c9-ad34-e56c6d82e76a" alt=""><figcaption></figcaption></figure>

### Microphone permission

To use the microphone, you will need to have the correct permissions in your browser. You will be prompted to grant access the first time you try to use microphone.

If you have previously denied microphone access, you can modify it in the browser extension settings:

1. Go to extension site settings - copy and paste this URL in your search bar: <kbd>chrome://settings/content/siteDetails?site=chrome-extension://iohjgamcilhbgmhbnllfolmkmmekfmci</kbd>
2. In the permission list, select “Allow” for microphone permission

## Tab vs Desktop Recording

With Jam, you can record a single tab, an entire window, or your full desktop.&#x20;

<div align="left" data-full-width="false"><figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FoQuHkqZfbdP2yknXFr1a%2FTabvsDesktop.gif?alt=media&#x26;token=0f385753-e91d-4bf1-91d6-a3dfe28fdfdf" alt=""><figcaption><p>Switching between tab and desktop recording</p></figcaption></figure></div>

When you record a single tab, Jam only captures what's literally in that tab. That means Jam does not capture the browser URL bar, or any new windows (e.g. for login flows) that pop up external to the tab.

When you record a window or your entire desktop with the "Record desktop" option, Jam records the full scope of that window/monitor – including the browser URL bar.

Because Jam is purpose-built to help engineers understand bug reports at a glance, when you choose the "Record desktop" option, Jam will auto-include console logs and network requests from every tab you interact with during the recording (as long as Jam is installed in that browser window).&#x20;

That means, if you're trying to demonstrate a bug that spans across multiple tabs or windows (like something updating in one place but not in another), Jam can record that in real-time, and give engineers a holistic view of the bug even if it's not contained within a single tab. That way engineers can track a bug through multiple sites, tabs and windows.&#x20;

### Recording incognito tabs

Jam offers full support for incognito. See steps here to enable Jam on incognito windows:

{% content-ref url="incognito-sessions" %}
[incognito-sessions](https://jam.dev/docs/record-a-jam/incognito-sessions)
{% endcontent-ref %}

---

# Source: https://jam.dev/docs/integrations/webhooks.md

# Webhooks

Webhooks allow you to connect Jam to external systems and receive real-time notifications when key events occur.\
This makes it possible to automate workflows, trigger actions in Intercom, or log events in your internal systems without relying on polling.

{% hint style="warning" %}
Webhooks are currently in **beta**. To enable access for your workspace, please contact our Sales team.
{% endhint %}

***

### 🧪 Supported Events (Beta)

At this stage, Jam supports two events related to the Intercom workflow:

* **`intercom.recorder.recorded`** – fired when a customer records and submits their screen.
* **`intercom.recorder.opted_out`** – fired when a customer chooses not to record their screen.

{% hint style="info" %}
More events will be added as we expand the webhook beta.
{% endhint %}

***

### Sample Payloads

All webhook events share the same general structure:

* **`id`** – unique identifier for the event.
* **`type`** – the event type (e.g. `intercom.recorder.recorded`).
* **`created_at`** – timestamp of when the event occurred.
* **`data`** – object containing event-specific information.

Example (`intercom.recorder.recorded`):

```json
{
  "id": "evt_12345",
  "type": "intercom.recorder.recorded",
  "created_at": "2025-09-09T12:00:00Z",
  "data": {
    "conversationId": "215470686832743",
    "jamId": "9573a43b-3ec9-49ab-b7e4-bf6cfc4bdfc",
    "recording_url": "https://jam.dev/r/rec_12345"
  }
}
```

***

### The Webhooks Tab in Jam Dashboard

Inside the **Jam Dashboard**, you’ll find a dedicated tab for Webhooks under:\
**Settings → Integrations → Webhooks**

From this tab you can:

* Create and manage endpoints.
* Subscribe to supported events.
* Monitor active integrations.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F8a1bZHXOtNkZF8O1Tr13%2Fimage.png?alt=media&#x26;token=4bffe5a1-63a4-4a7d-850d-262a80b4acd2" alt=""><figcaption></figcaption></figure>

***

### The Webhook Portal

Beyond the initial configuration, you can monitor and debug deliveries in the **Webhook Portal**. It allows you to:

* **View logs** of all delivery attempts (success and failure).
* **Replay events** that failed to deliver.
* **Access your Signing Secret** to validate incoming requests.
* **Monitor statistics** such as delivery success vs failure rates.
* **Inspect messages** and see full payloads with headers.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F0jX9xkCbMBvm4Mne9blp%2FScreenshot%202025-09-10%20at%2009.32.46.png?alt=media&#x26;token=fdfc9ad2-5d0a-42b0-a6f1-00b7af01e8bf" alt=""><figcaption></figcaption></figure>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FUGsQxrlGcVwNm8t2A99B%2Fimage.png?alt=media&#x26;token=b364b29e-a863-4bb6-ba2e-9ad599d888e5" alt=""><figcaption></figcaption></figure>

***

### How to Configure

#### 1. Creating a Manual Endpoint

1. Go to **Settings → Integrations → Webhooks → Manage**.
2. Click **Add Endpoint**.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FufVVSNvzmIGOWngQmgvS%2Fimage.png?alt=media&#x26;token=64488a74-8656-4db7-943d-b20f6d81a8fd" alt=""><figcaption></figcaption></figure>

3. Enter your endpoint URL.
4. Select the events you want to subscribe to (e.g. `intercom.recorder.recorded`, `intercom.recorder.opted_out`).
5. Click **Create**.

***

#### 2. Using Connectors

In addition to generic endpoints, Jam also provides **specific connectors** for popular integrations like Intercom.

**a) Intercom Fin Connector**

If you’re integrating with **Intercom Fin**:

1. In the **Webhook** dropdown, select **Intercom Fin**.
2. Paste the URL you copied from Intercom.
3. Under **Subscribe to Events**, ensure only the following are checked:
   * `intercom.recorder.recorded`
   * `intercom.recorder.opted_out`
4. Click **Create**.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FR8gb0OutUohiigoYHJsu%2FScreen%20Cast%202025-09-10%20at%209.38.55%20AM.gif?alt=media&#x26;token=46d938c9-f3c0-4ff9-b279-f1bce24df58f" alt=""><figcaption></figcaption></figure>

That’s it — Jam will now send Intercom events directly into your workflow.

---

# Source: https://jam.dev/docs/get-started/welcome-to-jam.md

# Welcome to Jam

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FmTyhnd1isrNkGyWGaJLw%2FJam%20Sharepage.png?alt=media&#x26;token=0a580c3a-0445-419c-aa13-4dd8381cdc0c" alt=""><figcaption></figcaption></figure>

### About

Jam helps customer support, product and engineering teams capture and debug issues faster by capturing automatic technical context. Join 200K+ users who capture, feedback, issues and bugs with all developer details included.

### Start Guide

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th><th data-hidden data-card-cover data-type="files"></th></tr></thead><tbody><tr><td><strong>Getting Started</strong></td><td>Learn how to use Jam</td><td><a href="getting-started">getting-started</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FBs5vNMvHrK3pHyKzgqJ2%2FGet%20started.png?alt=media&#x26;token=cb7023d3-dac8-49e6-9ab0-d22f6aec2316">Get started.png</a></td></tr><tr><td><strong>Creating a Recording Link</strong></td><td>Collect issues from others</td><td><a href="creating-a-recording-link">creating-a-recording-link</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FkpN22EG2QPRJJIcsNYvc%2FCreate%20recording%20links.png?alt=media&#x26;token=2af9e1b8-608c-41c6-a1e6-7557bf024db6">Create recording links.png</a></td></tr><tr><td><strong>Creating a Jam</strong></td><td>Capture issues by yourself</td><td><a href="creating-a-jam">creating-a-jam</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FOtlVZHmrDgghfoybYJJ5%2FCreate%20Jam.png?alt=media&#x26;token=45238c18-623c-475e-9632-1bf8e7d3206c">Create Jam.png</a></td></tr><tr><td><strong>Team Setup and Integrations</strong></td><td>Connect your team and tools</td><td><a href="team-setup-and-integrations">team-setup-and-integrations</a></td><td><a href="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2F0d5f4JxJXpFaAT66VyKu%2FTeam%20setup%20and%20integrations.png?alt=media&#x26;token=fafe3f00-a635-48ad-ab14-f6c63107c527">Team setup and integrations.png</a></td></tr></tbody></table>

<br>

---

# Source: https://jam.dev/docs/administration/workspace-visibility.md

# Workspace Visibility

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FZMqMzQKWnSfoKETJ5MXn%2FSetting_%20Workspace%20Discoverability.png?alt=media&#x26;token=08077fda-de35-4cdd-ab82-0f10c4c11f2d" alt=""><figcaption></figcaption></figure>

### Overview

Workspace visibility makes it easier for people in your company to find and join your team's workspace in Jam. When enabled, new users who sign up with your company's email domain can immediately join your team workspace and start collaborating.

### Managing Workspace Visibility

Workspace visibility determines whether Jam surfaces your team during:

* **Sign-up** for new users with your company email domain
* **In-product prompts** for existing Jam users with your company email domain

{% hint style="info" %}
Users automatically join as **Viewers** and can be promoted to other roles by team admins
{% endhint %}

#### Default Behavior

Workspace visibility availability depends on your plan:

* **Free and Team Plan**: Available and enabled by default for all workspaces
* **Enterprise Plan**: Not available, as Enterprise workspaces use advanced security and team management controls
* **Legacy Plans**: Disabled by default. Upgrade to the new Team plan to enable this option

### Configure

Only workspace admins can change visibility settings:

1. Go to your workspace settings page.
2. Find the **Workspace visibility** section.
3. Toggle **On** or **Off**

{% tabs %}
{% tab title="On" %}
**Workspace visibility:&#x20;**<mark style="color:green;">**On**</mark>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FZMqMzQKWnSfoKETJ5MXn%2FSetting_%20Workspace%20Discoverability.png?alt=media&#x26;token=08077fda-de35-4cdd-ab82-0f10c4c11f2d" alt=""><figcaption></figcaption></figure>

**New users with your @company.com email**\
Any user signing up or using Jam with your company email domain sees an option to join your workspace instantly.

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FOzG2mbbCWt4ntSB8V6Fz%2Fimage.png?alt=media&#x26;token=bfa350db-2f2e-4c76-a8c0-75fb4ecb1a65" alt=""><figcaption></figcaption></figure>
{% endtab %}

{% tab title="Off" %}
**Workspace visibility:&#x20;**<mark style="color:red;">**Off**</mark>

<figure><img src="https://1990502200-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FtAIPUIiSH7MWC0IHLJuD%2Fuploads%2FJKyBJxGQVvvnz5oSLMLp%2Fimage.png?alt=media&#x26;token=eab4ae78-38e0-429d-9683-d66f16f514df" alt=""><figcaption></figcaption></figure>

**New users with your @company.com email**\
Your workspace is hidden from automatic discovery.
{% endtab %}
{% endtabs %}

#### Privacy Considerations

Workspace discoverability is separate from your [access controls](https://jam.dev/docs/administration/access-controls), which determine who can access your team's Jams:

* **Workspace visibility**: Controls whether users with your domain can find and join your workspace
* **Access Controls**: Controls who can view your team's Jams and folders

{% hint style="info" %}
Workspace admins receive notifications whenever someone joins their workspace through this feature
{% endhint %}

You can have discoverability enabled while still maintaining strict access controls for your team's content.

---

# Source: https://jam.dev/docs/integrations/zendesk.md

# Source: https://jam.dev/docs/jam-for-customer-support/zendesk.md

# Zendesk

1. Create a new [Recording Link](https://jam.dev/docs/recording-links#how-it-works) from the Jam browser extension.
2. Copy & Paste the customer conversation URL as the Recording Link name (e.g., <https://yourcompany.zendesk.com/agent/tickets/ABC-12345-XYZ>.
3. Share the Recording Link in the customer conversation.
4. When the recording is ready, you will receive an email with the customer recording with a reference to the corresponding customer conversation.

{% hint style="info" %}
If you want to capture logs and network requests from your Recording Links, follow this [set up guide](https://jam.dev/docs/jam-for-customer-support/send-recording-links-from-your-own-domain-and-collect-console-logs).
{% endhint %}