Webhook workflows

Webhooks let you react to every new Jam. The workflow recipes below are common patterns, each with steps for one or more no-code platforms, along with a code variant. Every workflow recipe assumes you already have a jam.created webhook endpoint. If you don’t, see Get Started with Webhooks first.

Open a PR from a Jam

Hand a new Jam to an agent that reads the bug and opens a fix PR.

Notify Slack on incoming Jams

Post a Slack message whenever a customer captures a Jam.

Auto-file a Linear or Jira ticket

Forward every new Jam to your tracker as a structured triage issue.

Prioritize Jams from key accounts

Filter by author domain and route high-value reports straight to the team.

Individual workflows

Open a PR from a Jam

Hand a new Jam to a coding agent that pulls the full context through Jam MCP, writes a fix, and opens a PR for review. Best for code-addressable bugs from a small set of senders (yourself, your QA team, a beta user).

This workflow runs an LLM agent against your repository. Scope it to a sandbox repo or a narrow set of paths before any merges land near production.

The flow:

jam.created fires.
A GitHub Actions workflow (or any runner you control) runs with the Jam ID.
The runner invokes an agent that calls Jam MCP for the recording, logs, network requests, and transcript.
The agent writes a patch in a new branch and opens a PR that links back to the Jam.

GitHub Actions
n8n with an agent

Add a repository_dispatch workflow

Create .github/workflows/jam-to-pr.yml and trigger on repository_dispatch with event type jam-created.

Deploy a small webhook receiver

Stand up a function (Netlify, Vercel, Workers) that verifies the Jam signature and POSTs to GitHub’s repository_dispatch API with the Jam ID in the client payload.

Add the function URL in Settings → Webhooks and subscribe to jam.created.

Invoke an agent inside the workflow

In the workflow, run Claude Code or your agent of choice with the Jam ID. The agent calls Jam MCP for context, edits files, commits, and opens a PR.

Scope the agent and gate the merge

Restrict the agent to specific paths, set required reviewers on the PR, and run the test suite before any human approves.

name: Jam to PR
on:
  repository_dispatch:
    types: [jam-created]

jobs:
  fix:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run agent
        env:
          JAM_ID: ${{ github.event.client_payload.jamId }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          JAM_API_KEY: ${{ secrets.JAM_API_KEY }}
        run: ./scripts/run-agent.sh

Pair this with Auto-file a Linear or Jira ticket: the ticket tracks the bug, the PR tracks the fix, and both reference the same Jam URL.

Team workflows

Notify Slack on incoming Jams

This workflow posts a Slack message whenever a Jam is captured through a Recording Link. Pair it with a public-facing Recording Link to collect feedback from your website and ping the team on every new report.

Zapier
n8n
Make
Code

Use this Zapier template or follow the steps below.

Create a Zap in Zapier

Open Zapier’s create Zap page.

Select Webhooks by Zapier as the trigger

Choose Webhooks by Zapier as the trigger app, then select Catch Hook.

Zapier trigger setup with Catch Hook selected for Webhooks by Zapier

Copy the webhook URL

Open the Test tab and copy the webhook URL Zapier generated.

Zapier Catch Hook test tab with a generated webhook URL and Copy button

Create a jam.created webhook in Jam

Open Settings → Webhooks, add a new endpoint, paste the Zapier URL, and subscribe to jam.created.

Webhook endpoint setup with jam.created selected in Jam

Send an example event

Open the endpoint’s testing view and click Send Example.

Webhook endpoint testing view with Send Example and the event schema

Test the Zapier trigger

Return to Zapier and test the trigger. Zapier shows a request record from the example event.

Zapier test records view with request A selected from a webhook sample

Add a Filter step for Recording Link origin

Add Filter. Select Origin, Exactly matches, and recording_link to send Slack messages only for Recording Link Jams.

Configure the Slack action

Add Slack as the action and map webhook fields into the message text.

Zapier Slack message action with webhook fields mapped into message text

Test and publish the Zap

Run a final test, then click Publish.

Zapier toolbar with Test run and Publish buttons

Add a Webhook trigger node

Set the HTTP method to POST and copy the production URL.

In Settings → Webhooks, add a new endpoint with the n8n URL and subscribe to jam.created.

Add an IF node to filter Recording Link Jams

Compare {{$json["body"]["origin"]}} to recording_link.

Add a Slack node

Use the Post a message operation and pull the Jam URL from {{$json["body"]["jamUrl"]}}.

Activate the workflow

Toggle the workflow to Active so n8n listens on the production URL.

Create a scenario with a Custom webhook trigger

Add Webhooks → Custom webhook and copy the generated URL.

In Settings → Webhooks, add the Make URL and subscribe to jam.created. Send an example event so Make learns the payload schema.

Add a Filter between trigger and Slack

Set the condition origin equals recording_link.

Add a Slack module

Use Create a message and reference jamUrl, author.email, and title in the message body.

Turn on the scenario

Click Run once to verify the flow, then toggle the scheduler on.

Deploy this handler to Netlify Functions, Vercel, or Cloudflare Workers, then register the URL in Settings → Webhooks.

import { Webhook } from "svix";

export default async (request) => {
  const payload = await request.text();
  const headers = Object.fromEntries(request.headers);

  let event;
  try {
    const wh = new Webhook(process.env.WEBHOOK_SECRET);
    event = wh.verify(payload, headers);
  } catch {
    return new Response(null, { status: 400 });
  }

  if (event.origin !== "recording_link") {
    return new Response(null, { status: 200 });
  }

  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      text: `New Jam from ${event.author.email}: <${event.jamUrl}|${event.title ?? "Untitled Jam"}>`,
    }),
  });

  return new Response(null, { status: 200 });
};

Auto-file a Linear or Jira ticket

Every jam.created event becomes a triage issue with the title, description, captured URL, and a link back to the Jam.

Zapier
n8n
Make
Code

Trigger on jam.created

Use Webhooks by Zapier → Catch Hook, copy the generated URL, and register it in Settings → Webhooks with the jam.created event.

Send an example event from Jam

Open the endpoint in Jam and click Send Example so Zapier picks up the payload shape.

Add the Linear or Jira action

For Linear, choose Create Issue. For Jira, choose Create Issue.

Map the fields

Title: title (fall back to Bug from <author.email> if empty)
Description: combine description, originalUrl, and jamUrl so the Jam is the first link in the ticket
Status: Triage
Team or Project: pick the triage destination
Labels: tag with the Jam origin

Publish the Zap

Run a test and turn on the Zap.

Add a Webhook trigger node

Copy the production URL and register it in Jam with jam.created.

Add the tracker node

Use Linear → Create Issue or Jira → Create Issue. Authenticate with an API key.

Map the fields

Title: ={{$json.body.title || "Bug from " + $json.body.author.email}}
Description: include {{$json.body.description}}, the Jam link {{$json.body.jamUrl}}, and the captured URL {{$json.body.originalUrl}}
Labels: add the value of {{$json.body.origin}}

Activate the workflow

Send another example from Jam to confirm the ticket lands.

Add a Custom webhook trigger

Copy the URL, register it in Jam with jam.created, and send an example event so Make learns the schema.

Add the Linear or Jira module

Pick Create an Issue. Authenticate with your tracker credentials.

Map the fields

Use the Jam payload for Title, Description, and Labels. Put the Jam URL on the first line of the description so reviewers click into the recording immediately.

Turn on the scenario

Verify with one example event, then enable the scheduler.

The example below files a Linear issue. Swap the API call for Jira’s REST endpoint if you use Jira.

import { Webhook } from "svix";

export default async (request) => {
  const payload = await request.text();
  const headers = Object.fromEntries(request.headers);

  let event;
  try {
    const wh = new Webhook(process.env.WEBHOOK_SECRET);
    event = wh.verify(payload, headers);
  } catch {
    return new Response(null, { status: 400 });
  }

  const title = event.title || `Bug from ${event.author.email}`;
  const description = [
    event.jamUrl,
    "",
    event.description ?? "",
    event.originalUrl ? `Captured on: ${event.originalUrl}` : "",
  ].join("\n");

  await fetch("https://api.linear.app/graphql", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: process.env.LINEAR_API_KEY,
    },
    body: JSON.stringify({
      query: `
        mutation IssueCreate($input: IssueCreateInput!) {
          issueCreate(input: $input) { success issue { id } }
        }
      `,
      variables: {
        input: {
          teamId: process.env.LINEAR_TEAM_ID,
          title,
          description,
        },
      },
    }),
  });

  return new Response(null, { status: 200 });
};

Customer workflows

Prioritize Jams from key accounts

Route Jams captured on key-account domains straight to the team and tag them with a priority label. Pair it with a Recording Link in your help center or status page so a VIP customer’s report never sits in a queue.

The flow:

jam.created fires.
Match the originalUrl host against a list of key-account domains, or look it up in your CRM.
If matched, post to a high-priority Slack channel and create a P0 ticket.
If not, fall through to your normal triage flow.

Zapier
n8n
Code

Trigger on jam.created

Use Webhooks by Zapier → Catch Hook and register the URL in Jam.

Add a Paths step

Zapier’s Paths branches on a condition. Create a path called Key account.

Filter the Key account path

Add a Filter: Original URL Contains acme.com OR bigco.com. Add one row per domain, or look the host up via Zapier CRM integrations.

Post to a priority Slack channel

In the Key account path, add Slack → Send Channel Message to #vip-bugs. Include the customer email, Jam title, and Jam URL.

Create a P0 ticket

Add Linear → Create Issue (or Jira). Set Priority to Urgent and add a P0 label.

Add the fallback path

In the default path, file the Jam in your normal triage queue.

Publish the Zap

Test each path with an example event from Jam, then publish.

If you maintain key accounts in HubSpot or Salesforce, swap the static domain list for a CRM lookup step before the Filter.

Trigger on jam.created

Add a Webhook trigger and register the URL in Jam.

Branch on the capture URL

Add an IF node. Condition: {{$json.body.originalUrl}} contains acme.com. Use an OR group for additional domains.

Wire the true branch to Slack and Linear

Add Slack → Post a message to #vip-bugs and Linear → Create Issue with priority Urgent.

Wire the false branch to your default triage

Send the payload to your existing flow or leave it to a second webhook listener.

Activate the workflow

Send a few example events from Jam with different capture URLs to confirm routing.

import { Webhook } from "svix";

const KEY_ACCOUNT_DOMAINS = new Set(["acme.com", "bigco.com"]);

export default async (request) => {
  const payload = await request.text();
  const headers = Object.fromEntries(request.headers);

  let event;
  try {
    const wh = new Webhook(process.env.WEBHOOK_SECRET);
    event = wh.verify(payload, headers);
  } catch {
    return new Response(null, { status: 400 });
  }

  const host = event.originalUrl ? new URL(event.originalUrl).hostname : "";
  const isKeyAccount = [...KEY_ACCOUNT_DOMAINS].some(
    (d) => host === d || host.endsWith(`.${d}`),
  );

  if (isKeyAccount) {
    await postToSlack("#vip-bugs", event);
    await createLinearIssue(event, { priority: 1, labels: ["P0"] });
  } else {
    await createLinearIssue(event, { priority: 3, labels: ["triage"] });
  }

  return new Response(null, { status: 200 });
};

More patterns

These flows share the same shape: pick up jam.created, call Jam MCP for full context, then do something with it.

Auto-triage a folder

Cluster a folder of Jams (bug bash, beta cycle, customer flow) into grouped tickets instead of one per duplicate.

Design QA into a PR

Turn a designer’s walk-through into either a fix PR or routed Figma comments.

Recordings into artifacts

Convert walk-throughs into doc drafts, test cases, or release notes with the MCP option to retrieve voice-over transcripts.

These patterns rely on Jam MCP for reading Jam content. See Get Started with MCP for the tool reference.

MCP

CLI

SDK

Webhooks

Open a PR from a Jam

Notify Slack on incoming Jams

Auto-file a Linear or Jira ticket

Prioritize Jams from key accounts

Individual workflows

Open a PR from a Jam

Team workflows

Notify Slack on incoming Jams

Auto-file a Linear or Jira ticket

Customer workflows

Prioritize Jams from key accounts

More patterns

Auto-triage a folder

Design QA into a PR

Recordings into artifacts

Open a PR from a Jam

Notify Slack on incoming Jams

Auto-file a Linear or Jira ticket

Prioritize Jams from key accounts

​Individual workflows

​Open a PR from a Jam

​Team workflows

​Notify Slack on incoming Jams

​Auto-file a Linear or Jira ticket

​Customer workflows

​Prioritize Jams from key accounts

​More patterns

Auto-triage a folder

Design QA into a PR

Recordings into artifacts

Individual workflows

Open a PR from a Jam

Team workflows

Notify Slack on incoming Jams

Auto-file a Linear or Jira ticket

Customer workflows

Prioritize Jams from key accounts

More patterns