Jam

React to a comment on a Jam — useful for acknowledging a comment you've already acted on. Works on anyone's comment, not just your own. Adding a reaction you already left is a no-op. Supported emoji: 🐛 (Buggy), 💜 (Love it), ✅ (Fixed), 👀 (Oooo), ❓ (Unclear), 👏 (Bravo), 🔥 (Fire), 👍 (Got it). This can notify the comment author by email and is visible wherever the comment is shared.

Attach a URL to a Jam, such as the pull request a proof Jam demonstrates, the CI run it came from, or another Jam. Pass a label when the page title would not say what the link is; otherwise teams with links on the share page see the host and path. Adding the same URL again changes nothing. Returns the resource. When you record proof of your work, add the pull request or ticket it proves as a resource. The URL shows on the Jam's share page, which can be public: do not pass a URL that carries a token, and a URL with a username or password is refused. Needs the permission that edits a Jam's title.

Deprecated: use getFrames with mode: "overview".

Add a new comment to a Jam bug report. The comment body supports Markdown formatting. To reply in a thread, pass parentId using a top-level comment's id from getDetails on the same Jam. Replies are one level deep and ignore playbackRelativeTimestamp. Use this to add notes, analysis results, or follow-up information to a Jam. This can notify other users by email, and the comment is visible to people who can access the Jam, including public viewers when sharing permits it.

Create a folder in the team to organize Jams into. Returns the folder's id and shortId, so a follow-up updateJam call can file a Jam into it right away. Folder names are not unique — call listFolders first if you mean to reuse an existing folder rather than add another one with the same name. If your membership permits self-upgrade, this can promote you from Viewer to Creator, affect seat billing, and email team admins.

Create a reusable recording link that lets anyone with the URL record and submit a new Jam. Optionally target a folder and set an expiration date.

IMPORTANT — logs require a connected domain: a link only captures console and network logs when it starts recording from one of the team's connected domains (a recording URL). A link created with no recordingUrlId produces a generic recorder link that captures NO logs. Before creating, call listRecordingUrls and ask the user which connected domain to record from — don't guess. If the team has no connected domains, warn the user the link won't capture logs and point them to the dashboard to connect one (https://jam.dev/docs/custom-recording-domain) before creating a logs-less link. If your membership permits self-upgrade, this can promote you from Viewer to Creator, affect seat billing, and email team admins. It also emits a recording-link-created webhook event for configured subscribers.

Delete a comment from a Jam, along with its attachments. Only the comment's own author can delete it, so in practice this removes a comment you posted through createComment. Destructive and not recoverable: confirm with the user before calling. Comment IDs come from createComment's result or from getDetails.

Delete a folder and every Jam inside it. The Jams leave the team's lists and search and nobody on the team can bring them back — the dashboard has no trash or archive view to restore them from. Returns how many Jams went with the folder, as archivedJamCount. Destructive and not recoverable: confirm with the user before calling, never tell them the Jams can be restored afterwards, and use listFolders first so they can see what the folder holds. Takes a folder ID or short ID from listFolders, never a folder name — a name could match the wrong folder.

Delete a Jam. It leaves the team's lists and search results, and nobody on the team can bring it back — the dashboard has no trash or archive view to restore it from. Destructive and not recoverable: confirm with the user before calling, and never tell them the Jam can be restored afterwards.

Delete a recording link by its publicId, so it stops accepting new recordings. This is a soft delete: existing Jams recorded through it are untouched. Returns the publicId and the deletedAt timestamp. An unknown, already-deleted, or another team's publicId reads as not-found.

Rewrite a comment you previously left on a Jam, so an agent can correct or extend its own note instead of stacking a follow-up comment. Takes the comment ID returned by createComment. The new body replaces the old one entirely and is Markdown. You can only edit comments you authored. Changes are visible to people who can access the Jam, including public viewers when sharing permits it.

A Jam as a citable document: id, title, url and text (what getDetails returns). Use getDetails to investigate.

The Jam's console output as text, one message per line: [M:SS #index] level: message, with the stack trace and source under it. logLevel (['error','warn'] for problems) and limit filter server-side; the first line gives the match count, and a More: line the cursor for the next page.

The entry point for any Jam: call it first. Returns what the Jam is (title, description, author, page, browser and OS), its comments and links, the recording's timeline in time order, and a guide to what else the Jam holds and which tool reads it. A comment pinned to a playback time shows it as [M:SS]. format: "json" returns the structured payload instead of the text (IDs, folder, event counts, processing status, and on a video Jam a public 360p thumbnailUrl for each pinned comment, to share with a person). Once you find the cause or fix it, post one createComment that says so and mentions the creator as @[Name](user:<author.id>), unless the creator is the user you act for. Then call submitFeedback once with this Jam's jamId and evidence set to the Jam data that led you there. The links list the Jam's resources (pull requests, tickets, docs) and related Jams; when you fix or prove something, add the pull request with addResource and mark a proof or fix Jam as related to the bug Jam with markRelated.

The Jam's recorded events as text, one line each: [M:SS #index] then the request, console message or user action, details indented. Narrow it: index for the events timeline lines name; fromMs/toMs for everything around a moment; types (['network'], ['console'], ['user']); network statusCode (['4xx','5xx']), method, host, contentType; console logLevel (['error','warn']). Filters are arrays, OR within one and AND across; a network or console filter implies its type. Failed requests carry their bodies, and so does everything read by index or window; bodies:'all' for every body (cut at 4KB), headers:true for headers. format:'json' returns every stored column. The first line gives the match count and the UTC time of [0:00].

Still frames from a video Jam, as images. Set mode: 'overview' for one labeled grid across the whole video (start here); 'at' with at timestamps in ms; or 'window' with count evenly spaced frames, optionally within fromMs–toMs. size sets the frame height (not for the overview). At most 30 frames a call. Videos on Cloudflare Stream only; otherwise one text block says why.

Custom metadata the app attached with the jam.metadata() SDK: user IDs, versions, feature flags.

The Jam's network requests as text, one per line: [M:SS #index] METHOD url → status (initiator, type, duration), with the error, bodies and headers under it. index reads just the requests timeline lines name, with their bodies. Other filters are arrays, OR within one and AND across: statusCode (['4xx','5xx'] for failures), method (['POST','PUT','PATCH','DELETE'] for writes), host, contentType. Only failed requests carry their response body unless bodies:'all' (every body, cut at 4KB: filter first). headers:true adds request and response headers, secret values redacted at capture. The first line gives the match count and the UTC time of [0:00], to match backend logs.

Get a single recording link by its publicId. Returns the link's name, type, target folder, expiration, and the number of Jams recorded through it (jamsCreated). Use listRecordingLinkJams to page through those Jams.

Start verifying a connected domain (recording URL) so recorded Jams from it capture console and network logs. Returns a verifyUrl a HUMAN must open in a browser where the Jam extension or snippet is live on that domain — the recorder there confirms Jam is present and marks the domain verified. This tool does NOT verify the domain itself; it only hands back the link. After the user opens it, poll listRecordingUrls until the domain shows verified: true (the link expires in 5 minutes). Use this instead of sending the user to the dashboard to connect a domain.

The images of a screenshot Jam. Screenshot Jams only: a video Jam has getFrames.

The user's clicks, typing and navigations as text, one per line: [M:SS #index] click on <element> at x,y with its CSS selector; a click a script fired is marked. The getDetails timeline already lists these: call this for selectors, positions and typed values.

AI chapters of a video Jam: { status, chapters: [{ startMs, endMs, title, thumbnailUrl? }], language }; chapters is null unless status is "ready". thumbnailUrl is a public 360p JPEG to show a person; to look yourself, call getFrames with mode 'at' at the chapter's midpoint. "not_requested": never queued; "skipped": too short to segment.

What the reporter said while recording, as WebVTT with timestamps. Video Jams recorded with the microphone on only. The getDetails timeline already carries it as Voiceover: lines.

List folders in the team with optional search and pagination. Returns folder metadata including name, short ID, Jam count, and timestamps. Use this to discover available folders for organizing Jams.

Deprecated: use searchJams instead. Lists Jam bug reports with the legacy filters and pagination: search by text, filter by type (video/screenshot/replay), origin (capture surface), folder, author, URL, or creation date. Returns Jam metadata including title, origin, author, folder, and timestamps. Each returned Jam carries a url, the share link to hand back to the user unchanged: it carries search attribution.

List team members with optional search and pagination. Returns user metadata including name, email, and role. Use this to find users for filtering Jams by author.

List the Jams recorded through a recording link, addressed by the link's publicId. Returns each Jam's id, title, and createdAt (newest first), plus cursor pagination. Pass cursor (a jam id from a prior endCursor) to fetch the next page; hasNextPage indicates whether more remain.

List the team's recording links, newest first, with cursor pagination. Returns each link's publicId, name, and type. Pass cursor (a publicId from a prior endCursor) to fetch the next page; hasNextPage indicates whether more remain. Revoked links are excluded unless includeRevoked is true.

List the team's connected domains (recording URLs) — the domains a recording link can start from so recorded Jams capture console and network logs. Returns each domain's id, url, and verified state. Use this before createRecordingLink to pick the recordingUrlId to record from, and to tell whether the team has any connected domains at all. Only a verified domain captures logs; an unverified one must be verified from the dashboard first (https://jam.dev/docs/custom-recording-domain). An empty list means the team has no connected domains, so any link created now captures no logs.

Mark a Jam as related to another Jam of the same team, with a type read from the first Jam: it fixes the target, proves it, or relates_to it (the default). Teams with links on the share page show it on both Jams; the target shows the inverse ("fixed by", "proven by"). Marking again with the same type changes nothing. Returns the relation. When you record a Jam that proves a fix, mark it as fixes or proves of the bug Jam. Use it to connect a set of Jams of one flow, such as one Jam per UI state. Needs the permission that edits a Jam's title.

Remove every relation from a Jam to another Jam, whatever its type. The target Jam's backlink goes too.

Take back a reaction you left on a comment. Only removes your own reaction; other people's reactions with the same emoji are untouched. Removing a reaction you never left is a no-op. Supported emoji: 🐛 (Buggy), 💜 (Love it), ✅ (Fixed), 👀 (Oooo), ❓ (Unclear), 👏 (Bravo), 🔥 (Fire), 👍 (Got it). Changes are visible to people who can access the Jam, including public viewers when sharing permits it.

Remove a URL from a Jam's resources. Pass the URL exactly as it was added.

Resolve a video Jam in the connected team from a UUID or jam.dev URL in the query; at most one result. No title search: use searchJams.

Search the connected team's Jams. text matches every term against a Jam's title, description, comments, linked issue titles, the reporter's email or external id, and its transcript; a term made of only one or two letters or digits is matched against comments only through the whole text: a comment that contains the text as typed matches when another term has three or more letters or digits, or punctuation next to them (such as cool or #12). Terms like #12 or v1.2 also match comments on their own. textIn limits which of those places a term may match in. where is a list of { field, op, value } filter leaves, all ANDed; the where description lists every field, its operators and what it means. window bounds created_at, sort orders the page, and page carries the limit and the opaque cursor the previous page returned. The team is the one the token was issued for and no argument can name another. Each returned Jam carries a url, the share link to hand back to the user unchanged.

Save feedback about a Jam surface in Jam's database for Jam's agents to read. Returns the stored feedback ID and a thank-you. Use it when a Jam MCP tool, CLI command, doc page, or skill was wrong, stale, confusing, or missing something — and when one worked unusually well. Also send it when you find the cause of a Jam's problem or fix it: set jamId to that Jam and evidence to the Jam data that led you there, and say in the body what in it pointed to the cause. Report problems only with Jam's own surfaces: not with another MCP server's tools, the user's own skills or scripts, or the user's product, because Jam cannot fix those. The evidence report is for bugs in the user's product. Call it yourself; do not ask the user for approval, because no person reads it. Send at most one problem report per session, plus one evidence report for each Jam whose cause you find, and never for a slip you corrected yourself. Keep the body within 2000 words and 100,000 characters, and specific enough to act on: what you were doing, what you expected, what happened, and the mistake. Larger bodies are rejected without saving or truncating them. Never include secrets, customer data, source code, or stack traces — describe code rather than pasting it.

Rename a folder. Identify the folder by name, folder ID, or folder short ID. Renaming does not move any Jams — use updateJam for that. An unknown folder, or one belonging to another team, reads as not-found.

Update a Jam bug report: rename it, rewrite its description, or move it between folders. Every field is optional — only the ones you pass are changed. Use folder name, folder ID, folder short ID, or "root" to move to the root level. Editing the title or description requires an Admin or Creator role.

Update a recording link by its publicId. Only the fields you pass are changed. Use it to rename the link, change the destination folder for future recordings, set the default Jam title, change the reference, set an expiration, or replace the metadata. Unknown or other-team links return not-found; revoked links cannot be edited. Existing Jams are not moved.