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.

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:

You can also turn off Instant Replay for specific websites:

Jam is a browser extension that allows you to create the perfect bug report in just one click. You will now be able to capture an instant replay of the bug happening on your web app and include all the developer logs required to cut your bug reporting time by 20x.

You're joining 200K+ people who are logging bugs faster. Jam is the first screen recorder purpose-built for bug reporting and is integrated with all your issue-tracking tools (Jira, Linear, Asana, more) so there is no disruption to your software development workflows and tools.

Our promise to you? We want to help you fix and ship code so much faster, that way you can all get back to what you love doing, building.

What is Jam?

With Jam, in one click, you can: take a screenshot, record a video, or capture an instant replay, and Jam will instantly generate a link to share with your team.

The Jam link will also include all the technical diagnostic info your engineering team needs to quickly debug, such as network requests, console logs, device information, and even network speed! It's all captured so you no longer have to reproduce or find the technical diagnostics before reporting the bug.

Once you have your Jam link, simply paste it into a ticket or chat message to share it with engineers, or connect Jam to your issue-tracking tool of choice to create tickets right from Jam. No account is required to view, so engineers can click the link, and at a glance see the bug and why it happened.

We 💜 our users – hear directly from them

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.

Instant Replay allows you to capture a bug that just happened – with all the complete technical session details – and share it with an engineer in 2 clicks.

The goal of Instant Replay is to save you time and headache. Instead of having to stop what you’re doing, and go back and re-record bugs as you spot them, you can capture an Instant Replay in 2 clicks, share it with an engineer, and get back to what you were doing.

When you create an Instant Replay of a bug, Jam captures the following technical diagnostics and auto-includes them to help your engineers debug faster:

• Up to 2 minutes session replay of the DOM

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

How far back can Instant Replay capture?

Instant Replay can capture up to 2 minutes of the session recording, but in cases where the tab is just opened, or the website has heavier data, Jam may capture less time in the Instant Replay. If there’s a part of the Instant Replay a user does not want to share, they are given the ability to crop which section of the video they want to share.

Welcome to Jam! You're about to join 200K+ happy users who report bugs 20x faster – with all the details auto-included for engineers.

Here's a quick tutorial on how to Jam:

“I had never worked with engineers before. It’s hard for me to imagine having as much a seat at the table without Jam” – Jam user

Let's go! 🚀

Step 1: Install the Jam extension

Remember to pin the extension to your browser so it’s faster for future you!

When prompted, enter your email to create your account.

Now you’re ready to catch your first bug with Jam.

Step 2: Capture your first bug with Jam

Click on the Jam icon in your browser.

Choose your screen recording method – screenshot, video, or instant replay (hint: you don't have to repro the bug with instant replay!).

Draft your bug report, and hit “Create”!

Step 3: Check out your first Jam!

Your newly created Jam will open automatically in a new tab. Go check it out!

In the Jam, you'll see:

• Metadata: URL, timestamp, country, device, browser, OS information & network speed

• Developer logs: console logs, fully inspectable network requests

• Context: Cropped & full screenshot (if your Jam is for capturing a screenshot)

• JamGPT: an AI assistant that gives engineers pointers on how to fix bugs

• App integrations: send your Jam to your ticketing system (like Jira, Asana, etc)

• Workspace picker: organize your Jams into team workspaces

• Sharing & access settings

To share your Jam, simply copy the link and send it to your teammates. Or, you can share it with your teammates via email by clicking the "Invite" button.

Your teammates won't need to create an account to view it. (Unless you change the Jam's access settings to require login to view).

You'll get a notification when someone views your Jam for the first time!

Step 4: Invite your teammates

Help your teammates report bugs faster, with all the technical details engineers need auto-included. Anyone can create a team workspace in Jam and invite their team to join.

Step 5: Connect your tools

You can connect the tools you already use to Jam so that it fits right with your existing workflow.

To see what apps Jam integrates with, head over to your account or team settings in Jam.

Then, you can select these apps when you create Jams to send Jams to your other tools:

And, you can send existing Jams to your tools after the fact, later:

Step 6: There is no step 6! All done.

Enjoy your new, faster bug-reporting process! 🚀

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 Note: available for tab recording only
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. Note: Elements cannot be blurred after the recording, only before or during the recording.
4. During window recording you can blur elements across multiple tabs

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.

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.

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:

Drag to crop a screenshot.

Drag an area of the screen to take a cropped screenshot of that area.

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.

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.

Easily highlight key details in your video recordings using annotations, and help engineers quickly understand the issue you're reporting.

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.

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.

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.

To enable the microphone, you will need to have the correct permissions in your browser. You can enable these permissions by:

1. Clicking the Jam extension

2. Next to the Microphone icon, click the “Grant Permission” button (if it doesn't say "Grant Permission", then you already have the proper settings)

3. On the browser modal, click “Allow”

Then you can mute and un-mute your microphone and choose which microphone Jam should use to record your audio.

Tab vs Desktop Recording

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

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

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.

Recording incognito tabs

Jam offers full support for incognito. To capture console logs and network requests occurring on your desktop in incognito tabs, simply enable Jam for incognito in your browser extension settings:

Every Jam automatically includes developer information to help engineers see browser state and debug technical issues.

Here's what's included in Jam's DevTools today:

• Console logs

• Fully inspectable network requests and timing waterfall

• Session metadata: URL, timestamp, country, network speed

• Device metadata: device, browser, OS, viewport info

You can swap the docking of Jam's DevTools from side to bottom.

You can also use the same keyboard shortcuts in Jam as in Chrome DevTools:

⌘+⇧+D switch dock position

↑↓ move through network requests

⏎ / ESC open & close network requests

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.

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.

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

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). See steps here to enable Jam on incognito windows:

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.

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.

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

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.

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

Why do I see "JAM_DOES_NOT_SAVE_SECRETS"?

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

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

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

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

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.

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.

All of Jam's features are fully supported in incognito.

Many people use incognito to dogfood, test and capture bugs. Of course we’d want to make all of the Jam features like instant replay and screen recording packaged up with the network/console/device data – all available in private browsing mode.

To get started, all you have to do is enable incognito access from your browser’s extension settings (on Chrome, this can be done by going to chrome://extensions and clicking on Jam extension settings):

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.

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.

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

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.

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.

Getting Started

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

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

1. 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:

// 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
});

1. 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!

Your Jam should include metadata that looks like the following:

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

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:

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!

You can use keyboard shortcuts to control the Jam extension!

The default keyboard shortcuts can be found by hovering over each button in the extension.

(Behind the scenes note: Chrome has a limit of only 3 default keyboard shortcuts per extension so that's why Desktop Recording doesn't have its own keyboard shortcut, we had to choose only 3)

Edit the extension's keyboard shortcuts

You can edit which keyboard shortcuts work for the Jam extension in extension settings:

Engineers benefit when everyone at the company reports bugs to them in a consistent, predictable and highly detailed format. That's why the majority of Jam users onboard their teammates to use Jam as well.

How to create a team workspace and invite your teammates

You can create a team workspace in multiple places across the product: in the dashboard, the extension modal, or in the Jam page.

Here’s how to create a team workspace from Jam dashboard:

2. Click "Invite Teammates" or "Add a Team”
3. Enter your team name
4. Invite your teammates by entering their emails. You can also invite your team with an invite link. We will generate it for you once you finish creating your team.
5. Add payment information to start your 14-day free trial Note: you can cancel the subscription anytime during the trial

Payment Information

As part of the team workspace creation process, you'll need to provide payment information upfront:

• Your credit card will not be charged during the 14-day free trial

• At the end of the trial, your card will be automatically charged for your plan

• You can cancel your subscription at any time during the trial

A guide to team permissions

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.

Check how these seat types work: Manage Seats in Jam

Managing who can access Jams created by your team

Jams need to be flexible. Some Jams are internal and secret, but some need to be shared with people outside the company, like users or contractors.

You can define who has access to your Jams in the team settings page (only team admins can modify these settings) or on per-jam basis.

Default Access Controls

When you create a team workspace, access controls are automatically set based on your email domain:

• Company email detected: If you create a team with a company email (like name@company.com), access controls default to Private (only people with your company email can access)

• Personal email detected: If you create a team with a personal email (like gmail.com), access controls default to Public (anyone with the link can view)

You can modify the default access controls in your team settings page.

If you choose "Anyone with the link", anyone with the Jam link will be able to view it. This is the most common, because it makes it easiest for engineers across the company to view Jams without needing to create a Jam account or login to view.

If you pick "Only verified domains", you can define which email domains can access your team’s Jams. For example, if you work at ABC Company, you can set up your access control such that an @abc-company.com email address is required to view Jams.

You can also control who gets access to each Jam on a case-by-case basis.

To do that, open a Jam. Then click on the Invite button to set the privacy of a Jam. You can choose between public (anyone with the link can view) and private (requires login to view).

You can also share a single Jam with individual users by typing their email.

When you give access by an email address, that person is emailed to notify them that a Jam has just been shared with them.

Who can use this feature

• Available on all Pro, Team and Enterprise plans.

• Each member of a Jam workspace has a seat. The seat type determines what they can do within your workspace and how they affect your billing.

Your workspace’s plan, along with the number and type of paid seats, determines your subscription cost.

How seats work in Jam

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.

Here’s how these seat types work:

Viewer (free)

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

Creator (paid, default)

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.

Admin (paid)

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.

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.

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

   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

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.

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.

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.

Workspace discoverability 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 Discoverability

Workspace discoverability 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

Default Behavior

Workspace discoverability 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

How to Configure Discoverability

Only workspace admins can change discoverability settings:

1. Go to your workspace settings page.

2. Find the Workspace visibility section.
3. Toggle On or Off

   1. On - Any user signing up or using Jam with your company email domain sees an option to join instantly.

   2. Off - Your workspace is hidden from automatic discovery.

Privacy Considerations

• Workspace Discoverability: Controls whether users with your domain can find and join your workspace

• Access Controls: Controls who can view and edit your team's Jams

You can have discoverability enabled while still maintaining strict access controls for your team's content.

To configure SSO for your Jam workspace:

• You must be a team admin.

• You must have admin access to your identity provider (IdP)

1. Go to your team settings (General tab) and find Access section:
2. Click on the Setup button for Identity Provider option and follow a step-by-step walkthrough to configure SSO with your identity provider.

3. Once the SSO is successfully configured you’ll see your IdP listed on the page, and all team members will be able to log in using SSO:

How to configure Directory sync for your organization

Directory Sync allows you to automatically manage team members through your IdP. When Directory Sync is configured, any changes you make in your identity provider will automatically be synced in Jam.

1. Go to your team settings (General tab) and find Access section.

2. Click on the Setup button for Active directory option and follow a step-by-step walkthrough to configure directory sync with your identity provider.

3. Once the directory sync is successfully configured you’ll see your IdP listed on the settings page, under General tab:

Now, when a new user is added to your identity provider, that user will automatically be added to your Jam team.

User management

How you manage team members will depend on whether you have Directory Sync enabled.

With Directory Sync:

User provisioning happens in your identity provider. All team members will get an email once they are provisioned. Note: provisioned users get a Creator role by default.

You can also access the settings from Jam, under Team tab, using the Manage members option:

You’ll be redirected to a directory sync management page, where you can also provision access via user groups in your IdP by selecting which groups to sync:

User roles are managed manually in team settings in Jam. Note: mapping user groups to specific team roles is not supported.

Removing users: once you remove user from your identity provider they will automatically lose access to the Jam account associated with company email.

Without Directory Sync:

Provisioning and roles are managed directly in Jam. You can add users, change user roles, or remove users manually in your team settings:

Track important workspace changes with audit logs, control how long Jams are stored with custom data retention policies, and secure authentication with Single Sign-On (SSO). These features help you maintain control, security, and visibility over your Jam workspace.

Single Sign-On

SSO with SAML enables teams to log into and sign up to Jam with a single set of credentials, integrating seamlessly with identity providers such as Okta, OneLogin, Azure, and Auth0.

Audit logs

Audit logs provide a record of key team activities within your Jam workspace. s

What's included

• Access control changes: Changes at team, folder, and Jam levels

• Membership events: Invitations, removals, and role changes

• Team settings changes: Data retention changes, AI feature toggles

Data retention policy

Control how long Jams are stored in your workspace.

By default, all Jams in your workspace are saved indefinitely.

Enterprise customers can set custom retention periods to automatically delete Jams after a specified time.

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

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

1. Right click on the website and select "Inspect"

2. In the top left corner of dev tools, click the mobile inspector tool:

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

Quickstart - Setting up Recording Links with console logs, network requests

Soon you'll be able to see dev logs and other debug details from anyone who uses your link to record a bug. Never hop on a debugging call again!

Ready to get started?

You'll need write permissions to your website to complete these three steps:

• Register one or more Recording URLs with Jam (so we can generate links to your site)

• Set up Jam's Recorder UX on your Recording URLs (so your users can start recording)

• Install Jam's Capture Script across your site (so Jam can capture page context)

Follow this walk-through and you'll be done in no time!

1. Register one or more Recording URLs

Navigate to your Jam team's settings page, and click the "Recording Links" tab.

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.

2. Set up Jam's Recorder UX

Use Jam.js' Recorder script to initialize a recorder on your page. This will cause our Recorder UX to pop up over your page when users open your Recording Links.

<html>
  <head>
    <!-- Put this anywhere in your <head> -->
    <script type="module" src="https://js.jam.dev/recorder.js"></script>
    <meta name="jam:team" content="my-team-id-from-dashboard" />
  </head>
</html>

If the user dismisses the Recorder UX before starting a recording, they must re-click your Recording Link to try again.

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.

3. Install Jam's Capture Script

Use Jam.js' Capture script to capture events (such as console logs, network events, clicks, and keypresses) on your pages. These will be shared with our Recorder UX to save with your users' recordings, and otherwise ignored.

<html>
  <head>
    <!-- Put this as early as possible in your <head> -->
    <script type="module" src="https://js.jam.dev/capture.js"></script>
  </head>
</html>

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.

Troubleshooting - Modify CSP

(If your site does not specify CSP directives, you can skip this step.)

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:

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.

FAQs

• Q: Can I put the Recorder and Capture scripts on the same page? A: Yes! There is no danger in doing so.

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

With Jam, your customer support team can service more customers by spending less time on each conversation, and engineers can fix issues faster.

Support agents can request a screen recording from your customers, and get a Jam with all information engineers need to debug the issue. It's all captured so your agents no longer have to reproduce or find the technical diagnostics before reporting the bug.

Getting started

How to use Jam + Intercom

1. First you’ll need to make sure you have a team on Jam. Here's how to create a team if you don't have one already: Team Workspaces

2. From the team dashboard, go to the team settings and select Connected Apps tab. Click on Intercom and go through the authorization flow.
3. 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.
4. Once your users report an issue, an agent can request a screen recording with Jam Tip: you can also customize the message your users see
5. Once user submits the recording, an agent receives a note with the Jam

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

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

Here’s a preview of what you’ll get with every support ticket:

How to set up Jam.js?

Installing Jam.js takes under 5 min guaranteed, and if it takes you a second longer, we'll buy you a pizza. 🍕

2. Copy the team ID from the URL

3. Add the team ID to this code snippet

4. Paste the snippet into your web app's codebase

In order to guarantee jam.js can properly capture console and network requests, it should be the first <script> tag on the page.

For example, here’s where the jam.js script would go in an example template HTML file for a Single Page App:

Because we include the async and defer tags within the script snippet, fetching the jam.js script will not impact page load times.

5. Modify CSP (if your site has this enabled)

(If your site does not specify CSP directives, you can skip this step.)

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:

• frame-src

• script-src

How to test jam.js?

Once jam.js is installed, every Jam your users create will have console logs and network requests attached.

To test this out, issue a screen recording request, and begin recording your web app.

Open devtools for your web app, and run the following test commands in console:

Now, you should have console and network events generated and captured for your recorded Jam.

To confirm, submit the Jam, then open its link and click on the Console and Network tabs. Your Jam should include at least 1 console and network event, each.

Here’s how this might look:

Current limitations

• If Jam.js is installed within an iframe, the top level logs will not get captured, e.g. using Jam.js on embedded Shopify apps.

• Console and network event capture is currently unavailable for Jams created in Firefox, Safari, or incognito mode. Support for these browsers is coming soon.

• Because we include the async and defer tags, the first page load (or any page load, when cache is disabled) will not guarantee Jam.js runs early enough to capture console and network requests. This is a tradeoff we’ve made to make sure we do not impact your app’s load times.

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

With Jam AI you can easily create clear and accurate bug reports, in one click. That way engineers always get a useful ticket, and can pinpoint the root cause faster, using AI debugger.

Jam AI's feature set includes:

• 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 Note: not available for screenshot Jams

How to control AI features

Team-level settings

You can disable or enable Jam AI for your whole team in the team settings, under the “Admin & Security” tab. So you can easily prevent AI generation by team members according to your company policy.

AI-capture settings

You can also control AI features while you’re creating a Jam, by enabling or disabling the toggle. Your selection will be persisted for the following Jams.

AI debugger is an AI debugging assistant, aimed at helping the engineers who receive Jam bug reports debug and fix code faster.

It's integrated into Jams and uses logs, network requests, device data, and session replays to identify root causes and recommend fixes.

AI debugger has all the context of the browser during the bug (because it is fed with data from the Jam). And then it saves you some Google searches and suggests to you some fixes. Then you can give it the broken code and it will rewrite it with the fix.

AI debugger offers the following functionalities to simplify the debugging process:

• Identify root cause – With full context of the bug report, AI debugger suggests potential causes, eliminating the need for endless Stack Overflow searches.

• Fix code – Send broken code to AI debugger and receive bug-free, rewritten code in return.

• Tackle CSS issues – AI debugger knows CSS, and is ready to resolve responsive or design issues by rewriting your CSS.

• Adapt to any framework – Whether it's a JS framework or CSS library, AI debugger adjusts and provides suitable suggestions.

• Interactive pair programming – The chat interface allows continuous conversation with AI debugger, refining its suggestions based on your findings.

• Customize verbosity – Switch between verbose and concise modes depending on your needs, for detailed explanations or quick TLDRs.

Data privacy

We use the OpenAI API to power AI debugger.

AI debugger is opt-in, meaning your data does not touch the OpenAI API's unless you explicitly opt in by clicking "Yes" when asked:

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:

Installation

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Asana.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from Asana are shown in Jam:
6. Click "Create task" and once Jam creates your Asana task, it will automatically open in a new tab.

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

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:

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with GitLab.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from GitLab are shown in Jam:
6. Click "Create issue" and once Jam creates your GitLab issue, it will automatically open in a new tab.

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

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

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:

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with ClickUp.
4. 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.

   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.

5. Pro tip: you can click "Edit fields" to manage which fields from ClickUp are shown in Jam:
6. Click "Create task" and once Jam creates your ClickUp task, it will automatically open in a new tab.

How to send existing Jams to ClickUp

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 .
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.
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 Jam account or team workspace can connect to multiple ClickUp workspaces.

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.

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

1. After you are done connecting to ClickUp, you will be able to see which ClickUp workspace(s) are connected to that Jam team workspace.

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)

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.

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.

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:

Installation

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with GitHub.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from GitHub are shown in Jam:
6. Click "Create issue" and once Jam creates your GitHub issue, it will automatically open in a new tab.

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

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:

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Notion.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which properties from Notion are shown in Jam:
6. Click "Create page" and once Jam creates your Notion page, it will automatically open in a new tab.

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

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

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:

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Jira.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from Jira are shown in Jam:
6. Click "Create issue" and once Jam creates your Jira ticket, it will automatically open in a new tab.

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

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:

2. Click "Invite Teammates" or "Add a Team"
3. Jam will walk you through the steps of creating a team.
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.
5. Select the Jira site you want to connect to.
6. After you are done connecting to Jira, you will be able to see which Jira site is connected to that Jam team workspace.
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.

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.

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

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

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

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Linear.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from Linear are shown in Jam:
6. Click "Create issue" and once Jam creates your Linear ticket, it will automatically open in a new tab.

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

2. Click "Invite Teammates" or "Add a Team"
3. Jam will walk you through the steps of creating a team.
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.
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.
6. Now, when you create Jams, you can choose which Jam team workspace (and thus, which Linear workspace) to send each Jam to.
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.

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.

How to get started and connect Jam & Sentry

3. Done! Now you can view Sentry events right from Jam.

Now you will be able to see Sentry events from the same timestamp of the Jam right in the Jam.

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.

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.

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

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?

You can connect Slack and Jam in order to instantly send your bug reports to Slack right from Jam's browser extension.

Every Slack message you create with Jam automatically includes:

• Screen capture (screenshot, video or instant session replay)

• 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 – 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:

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Slack.
4. 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.
5. 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!

All done! Open up Slack to see your newly created Jam. It will format perfectly for engineers – whether it's a screenshot:

Or video/instant replay:

^ 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.
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.
5. Click "Send message" to create your Slack message.

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"
3. Connect Slack

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.

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.

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.

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

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.

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:

Installation

1. Next, capture your bug with Jam.
2. 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.
3. Jam will guide you through authenticating with Azure DevOps.
4. 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.
5. Pro tip: you can click "Edit fields" to manage which fields from Azure DevOps are shown in Jam:
6. Click "Create issue" and once Jam creates your Azure DevOps issue, it will automatically open in a new tab.

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

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

You'll find the links to the Fullstory session in the info panel in Jam logs.

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.

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.

Our security policies are supported by quarterly vulnerability tests, and annual exercises as dictated by SOC 2 Type II requirements.

Read more about Jam's security practices and compliance measures below.

SOC 2 Type II Compliance

Jam is SOC 2 Type II 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.

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

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.

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.

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.

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.

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.

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

Download

Download the Jam extension for Chromium browsers: