Can I link one commit to multiple Jira tickets?

Yes, modify the regex to use global flag 'g' and add an Iterator module to loop through all extracted keys. Each iteration creates a separate Jira comment.

What happens if the Jira ticket key doesn't exist?

Jira returns a 404 error and the scenario stops. Add error handling to continue processing or log invalid keys to a Google Sheet for review.

Does this work with private repositories?

Yes, Make's webhook works with private repos. Just ensure your GitHub connection has appropriate repository access permissions when you authenticate.

Can I customize the comment format for different commit types?

Add another router path that checks commit message prefixes (feat:, fix:, etc.) and routes to different Jira comment templates based on the type.

Why are some webhooks not triggering the scenario?

GitHub webhooks can fail during high traffic or Make maintenance. Check your repository webhook delivery logs in GitHub settings for failed attempts and HTTP response codes.

Beginner~12 min setupDeveloper Tools & Project ManagementVerified April 2026

How to Link GitHub Commits to Jira Tickets with Make

Automatically comment on Jira tickets when GitHub commits reference them, including commit details and author info.

Steps and UI details are based on platform versions at time of writing — check each platform for the latest interface.

Make

Also on:Zapier N8n Power-automate Pipedream

Best for

Development teams that need instant commit visibility in Jira tickets and push code multiple times daily.

Not ideal for

Teams that prefer daily digest emails or only commit a few times per week with manual ticket updates.

Sync type

real-time

Use case type

notification

Real-World Example

💡

A 12-person fintech startup uses this to automatically update Jira tickets when developers push bug fixes or feature commits. Before automation, product managers checked GitHub manually twice daily and missed critical commits for hours. Now stakeholders see commit progress immediately in their Jira tickets, reducing status check meetings from daily to weekly.

What Will This Cost?

Drag the slider to your expected monthly volume.

Monthly workflow runs

/mo

505005K50K

Each platform counts differently — Zapier: 1 task per trigger. Make: 1 operation per module per record. n8n: 1 execution per run.

$30/mo if billed monthly

Pipedream

$29/mo

Basic plan

Prices shown for annual billing. Based on published pricing as of April 2026.

Estimated ROI

1000

min saved/mo

$583

labor value/mo

Free

no platform cost

Based on ~2 min manual effort per operation at $35/hr fully loaded labor cost.

Implementation

Skip the setup

Import this workflow directly into Make

Copy the pre-built Make blueprint and paste it straight into Make. All modules, filters, and field mappings are already configured — you just need to connect your accounts.

Before You Start

Make sure you have everything ready.

GitHub repository with admin access to add webhooks

Jira project with permission to add comments to issues

Jira API token (cloud) or username/password (server)

Team uses consistent Jira key format in commit messages

Make account with webhook operations available

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Issue Key	`issue_key`	The extracted Jira ticket key from commit message using regex pattern [A-Z]+-[0-9]+
Comment Body	`body`	Formatted text combining commit message, author name, and GitHub commit URL
Commit Message	`head_commit.message`	Full commit message from GitHub webhook payload containing ticket reference
Author Name	`head_commit.author.name`	Git author name from the commit, may differ from GitHub username
Commit URL	`head_commit.url`	Direct GitHub link to the specific commit for easy access from Jira

1 optional field▸ show

Repository Name repository.full_name Full repo name in owner/repository format for context in comments

Step-by-Step Setup

Scenarios > Create new scenario > +

Create New Scenario

Start building your commit linking workflow by creating a new scenario in Make. This will be your automation container that connects GitHub to Jira.

1Click 'Create a new scenario' from your Make dashboard
2Click the large '+' circle in the center of the canvas
3Search for 'GitHub' in the app search box
4Select 'GitHub' from the results list

✓ What you should see: You should see the GitHub app icon on your scenario canvas with a configuration panel open on the right.

GitHub > Watch Events

Configure GitHub Webhook Trigger

Set up the webhook that fires when new commits are pushed to your repository. This trigger captures commit data in real-time.

1Select 'Watch Events' from the GitHub trigger options
2Choose 'push' from the Event dropdown menu
3Enter your repository name in format 'owner/repo-name'
4Click 'Add a webhook' and copy the provided webhook URL

✓ What you should see: The trigger shows a webhook URL starting with 'hook.integromat.com' and displays repository connection fields.

⚠

Common mistake — Don't select 'Watch Repository Events' — that catches all activity including issues and PRs, not just commits.

Make

click +

search apps

GitHub

Configure GitHub Webhook Tri…

GitHub

module added

GitHub > Connection > Add

Connect GitHub Account

Authenticate your GitHub account so Make can access repository data and register the webhook automatically.

1Click 'Add' next to the Connection field
2Select 'OAuth' as the connection type
3Click 'Continue' to open GitHub authentication
4Authorize Make to access your repositories
5Select your connection from the dropdown once created

✓ What you should see: You should see a green checkmark next to your GitHub connection and the repository field becomes active.

Make settings

Connection

Choose a connection…Add

click Add

GitHub

Authorize Make

popup window

✓

Connected

green checkmark

Tools > Set Variable

Add Jira Ticket Key Filter

Create a filter to only process commits that contain Jira ticket references. This prevents unnecessary API calls for commits without ticket keys.

1Click the '+' button after your GitHub trigger
2Select 'Tools' from the app list
3Choose 'Set Variable' as the module type
4Set Variable name to 'jira_key'
5Add formula: regexExtract(head_commit.message; "[A-Z]+-[0-9]+"; "g")

✓ What you should see: The Set Variable module appears connected to GitHub with the regex formula visible in the configuration panel.

⚠

Common mistake — Make sure the regex pattern matches your Jira project key format — adjust [A-Z]+ if you use different conventions.

GitHub

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Jira

notified

Flow Control > Router

Add Router for Conditional Logic

Insert a router to split the workflow path, ensuring we only proceed to Jira when a ticket key is found in the commit message.

1Click '+' after the Set Variable module
2Select 'Flow Control' from the categories
3Choose 'Router' from the available modules
4Click on the router to configure routing paths

✓ What you should see: A diamond-shaped router appears with multiple output paths available for configuration.

⚠

Common mistake — Filters are the most common place setups break. Double-check the field name and value exactly match what your app sends — a single capital letter difference will block everything.

Router > Filter

Configure Router Filter

Set up the router's filter condition to only continue when a Jira key exists. This prevents errors when commits don't reference tickets.

1Click the wrench icon on the router's top path
2Set Label to 'Has Jira Key'
3Click 'Set up a filter'
4Set Condition: jira_key 'Is not equal to' (empty)
5Click 'OK' to save the filter

✓ What you should see: The router path shows a filter icon and 'Has Jira Key' label above the connection line.

⚠

Common mistake — Test this filter with sample data — an empty regex result will break the workflow if not caught here.

Jira Software > Add Comment to Issue

Add Jira Module

Connect to Jira to post comments on tickets. This module will receive the commit data and create ticket comments.

1Click '+' at the end of the filtered router path
2Search for and select 'Jira Software'
3Choose 'Add Comment to Issue' from the action list
4Click 'Add' next to Connection to set up Jira access

✓ What you should see: The Jira module appears connected to the router with comment configuration fields visible.

Jira Software > Connection > Add

Connect Jira Account

Authenticate with your Jira instance using either cloud OAuth or server basic auth, depending on your Jira setup.

1Enter your Jira domain (e.g., 'yourcompany.atlassian.net')
2Select 'Basic' for server or 'OAuth 2.0' for cloud
3Enter your email and API token (cloud) or username/password (server)
4Click 'Save' to establish the connection
5Test the connection to verify access

✓ What you should see: A green 'Connected' status appears next to your Jira connection in the dropdown.

⚠

Common mistake — Use API tokens, not passwords, for Jira Cloud — passwords won't work and will lock your account after failed attempts.

Jira Software > Add Comment to Issue > Issue Key

Configure Issue Key Mapping

Map the extracted Jira key from the commit message to the issue key field. This tells Jira which ticket to comment on.

1Click in the 'Issue Key' field in the Jira module
2Select 'jira_key' from the Set Variable module output
3Verify the mapping shows the extracted ticket key
4Leave other fields like Project Key empty since we're using Issue Key

✓ What you should see: The Issue Key field displays the mapped variable with a small tag icon indicating dynamic content.

⚠

Common mistake — Don't manually type the issue key — always map it from the variable or commits without keys will fail.

GitHub fields

title

body

state

html_url

user.login

available as variables:

1.props.title

1.props.body

1.props.state

1.props.html_url

1.props.user.login

Jira Software > Add Comment to Issue > Comment

Build Comment Content

Create a formatted comment that includes commit details, author information, and a link back to the GitHub commit.

1Click in the 'Comment' text area
2Enter: 'New commit by {{head_commit.author.name}}'
3Add new line and enter: 'Message: {{head_commit.message}}'
4Add another line: 'View commit: {{head_commit.url}}'
5Format with Jira markup if desired (e.g., *bold* for emphasis)

✓ What you should see: The comment field shows a formatted template with GitHub data variables highlighted in different colors.

Scenario > Run once

Test the Workflow

Run a test to verify the complete flow from GitHub webhook to Jira comment creation works correctly.

1Click 'Run once' at the bottom of the scenario
2Make a test commit to your GitHub repo with a Jira key in the message
3Wait 10-30 seconds for the webhook to trigger
4Check the execution log for any errors or successful runs
5Verify the comment appears on the referenced Jira ticket

✓ What you should see: The scenario shows a successful execution with green checkmarks on all modules, and your Jira ticket has a new comment.

⚠

Common mistake — If testing fails, check that your GitHub webhook was actually created — go to your repo settings to verify the webhook exists and shows recent deliveries.

Make

▶ Run once

executed

✓

GitHub

✓

Jira

🔔 notification

received

Scenario > Settings > Activate

Activate the Scenario

Turn on the scenario to run automatically for all future commits. Set an appropriate schedule and error handling.

1Toggle the 'ON' switch at the bottom left of the scenario
2Set the schedule to 'Immediately' for real-time processing
3Click the gear icon and set error handling to 'Break'
4Add a scenario name like 'GitHub-Jira Commit Links'
5Save the scenario configuration

✓ What you should see: The scenario shows 'ON' status with a green indicator, and webhook processing begins for new commits.

⚠

Common mistake — Don't set error handling to 'Ignore' — you'll miss failed webhook deliveries and won't know when ticket keys are invalid.

Drop this into a Make custom function.

Copy this templateregexExtract(head_commit.message; "(?:fixes|closes|resolves)\s+([A-Z]+-[0-9]+)"; "i")

▸ Show code

regexExtract(head_commit.message; "(?:fixes|closes|resolves)\s+([A-Z]+-[0-9]+)"; "i")

... expand to see full code

regexExtract(head_commit.message; "(?:fixes|closes|resolves)\s+([A-Z]+-[0-9]+)"; "i")

Scaling Beyond 200+ commits/day+ Records

If your volume exceeds 200+ commits/day records, apply these adjustments.

Batch Multiple Ticket Keys

Use Make's Iterator module to process commits with multiple Jira references in a single message. This reduces total operations and prevents webhook timeouts from sequential processing.

Add Jira Rate Limit Handling

Insert a 1-second delay module before Jira comments and enable automatic retry with exponential backoff. Jira Cloud throttles at 1000 requests/hour per user, so heavy commit periods will hit limits.

Filter Bot Commits

Add author filtering to exclude automated commits from CI/CD systems and dependency updates. These rarely need Jira tracking and can consume operations unnecessarily during deployment cycles.

Going live

Production Checklist

Before you turn this on for real, confirm each item.

Test webhook delivery with a real commit, not sample data from Make's test runner

Applies when: Always

Verify GitHub webhook shows up in repository settings with recent successful deliveries

Applies when: Always

Set router error handling to 'Break' not 'Continue' to catch invalid ticket keys

Applies when: Always

Add retry logic with 3-attempt limit for Jira API timeouts during high traffic

Applies when: High volume

Configure webhook secret validation if repository contains sensitive code

Applies when: Enterprise

Set up scenario scheduling to 'Immediately' not polling interval for real-time processing

Applies when: Always

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy Make for this workflow

Use Make for this if you need real-time commit linking and your team pushes code frequently throughout the day. Make's webhook handling is instant — comments appear in Jira within 5-10 seconds of the commit. The visual router makes it simple to handle commits without ticket keys gracefully. Skip Make if you only need daily digest summaries — GitHub Actions with a scheduled workflow would be cheaper for bulk processing.

Cost

This workflow burns 2-3 operations per commit: one for the webhook trigger, one for the variable extraction, and one for the Jira comment. At 100 commits per month, that's 300 operations total. The Make Core plan at $9/month includes 10,000 operations, so you're well covered. Zapier's Starter plan costs $20/month for similar volume, making Make 55% cheaper. N8N self-hosted is free but requires server maintenance.

Tradeoffs

Zapier handles Jira's ADF comment formatting automatically — you get rich text without JSON structure headaches. N8N offers better regex debugging with step-by-step pattern testing in their expression editor. But Make's router system is cleaner than Zapier's filter-or-stop approach, and the visual scenario builder makes troubleshooting webhook issues much faster than N8N's node-based interface.

You'll hit GitHub's webhook retry behavior if your scenario errors out — failed deliveries get retried 5 times over 24 hours, creating duplicate comments if you fix the issue mid-retry. Jira Cloud rate limits at 1000 requests per hour per user, so high-commit-volume repos will throttle. Make doesn't automatically handle Jira's transition from ADF to plain text — comments with formatting markup will render as raw ADF JSON in older Jira versions.

Ideas for what to build next

→
Add Slack Notifications for Critical Commits — Route commits containing 'hotfix' or 'critical' to a Slack channel using another router path. Keeps the team informed of urgent changes in real-time.
→
Create Jira Ticket Status Updates — Extend the workflow to automatically move Jira tickets to 'In Review' status when commits are pushed. Requires additional Jira transition action after the comment.
→
Log All Commits to Google Sheets — Add a parallel path that logs every commit with timestamp, author, and linked tickets to a tracking spreadsheet. Useful for sprint reports and code review metrics.