Can I route bugs to different Jira projects based on GitHub repository?

Yes, add a router after the GitHub trigger and create separate paths for each repository. Each path connects to its own Jira module with different project settings.

What happens if someone removes the bug label from GitHub?

The Jira ticket stays open since Make only triggers on label additions, not removals. You'd need a separate scenario watching for 'unlabeled' events to close or update Jira tickets.

How do I handle GitHub issues with multiple priority labels?

Use Make's priority order in your conditional mapping - check for 'critical' first, then 'urgent', then default to medium. The first matching condition wins.

Can I update existing Jira tickets instead of creating duplicates?

You'll need to search Jira first using the GitHub issue URL or number, then use conditional logic to either update existing tickets or create new ones based on search results.

Why does my scenario sometimes miss GitHub label events?

GitHub webhook delivery can fail during network issues. Check your repo's webhook delivery history and enable webhook secret verification in Make for more reliable processing.

Beginner~12 min setupDeveloper Tools & Project ManagementVerified April 2026

How to Route GitHub Bug Reports to Jira with Make

Automatically create Jira tickets when GitHub issues are labeled as bugs, with severity mapping from labels.

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

Teams needing conditional bug routing with severity mapping from GitHub labels to Jira priorities.

Not ideal for

Simple one-to-one bug forwarding without priority logic or custom field requirements.

Sync type

real-time

Use case type

notification

Real-World Example

💡

A 25-person B2B SaaS development team uses this to automatically create Jira tickets when GitHub issues get labeled as bugs, with 'critical' labels routing to their on-call queue as High priority tickets. Before automation, developers manually copied bug reports from GitHub to Jira twice daily, often missing critical issues for hours. Now critical bugs trigger immediate Jira tickets that feed into their alerting system.

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 create webhooks

GitHub personal access token with repo permissions

Jira project with Bug issue type enabled

Jira API token for your account

Optional

Standardized GitHub labels for severity levels

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Issue Title	`title`	GitHub issue title maps directly to Jira summary field
Issue Description	`body`	GitHub issue body content becomes Jira ticket description
Label Names	`labels[].name`	Array of all labels on the issue for priority mapping
Issue Number	`number`	GitHub issue number for deduplication tracking

3 optional fields▸ show

GitHub URL	`html_url`	Link back to original GitHub issue for reference
Issue Author	`user.login`	GitHub username of person who created the issue
Repository Name	`repository.name`	Which GitHub repo the bug came from

Step-by-Step Setup

Scenarios > Create new scenario > GitHub

Create New Make Scenario

Set up a new scenario in Make to handle the bug routing workflow. This creates the foundation for connecting GitHub and Jira.

1Log into Make and click 'Create a new scenario'
2Click the gray circle with '+' in the center
3Search for 'GitHub' and select it from the app list
4Choose 'Watch Issues' as your trigger

✓ What you should see: You should see the GitHub module added to your scenario canvas with 'Watch Issues' selected.

GitHub module > Connection > Add

Connect GitHub Account

Link your GitHub account to Make so it can monitor issue label changes. You'll need a GitHub personal access token with repo permissions.

1Click 'Add' next to the Connection field
2Enter your GitHub username
3Paste your personal access token in the Token field
4Click 'Save' to test the connection

✓ What you should see: A green 'Connection successful' message appears and your GitHub username shows in the connection dropdown.

⚠

Common mistake — Make sure your token has 'repo' scope - without it, you can't read issue labels or create webhooks

Make settings

Connection

Choose a connection…Add

click Add

GitHub

Authorize Make

popup window

✓

Connected

green checkmark

GitHub module > Settings

Configure Issue Watching

Set up the trigger to monitor specific repositories for issue changes. This determines which GitHub repos Make will watch for bug labels.

1Select your repository from the Repository dropdown
2Set Event to 'Issues'
3Choose 'labeled' from the Action dropdown
4Set Limit to 10

✓ What you should see: The GitHub module shows your selected repository and 'Issues: labeled' as the trigger configuration.

⚠

Common mistake — Don't select 'Issues: opened' - you need 'labeled' specifically to catch when bug labels are added

Make

click +

search apps

GitHub

Configure Issue Watching

GitHub

module added

Connection > Set up a filter

Add Label Filter

Create a filter to only process issues labeled with 'bug'. This prevents the scenario from running on every label change.

1Click the wrench icon between GitHub and the next module space
2Select 'Set up a filter'
3Set Label to 'label.name' from the GitHub data
4Choose 'Equal to (case sensitive)' as the operator
5Enter 'bug' in the value field

✓ What you should see: A filter appears on the connection line showing 'label.name = bug'.

⚠

Common mistake — Match the exact case of your bug labels - 'Bug' and 'bug' are different and the filter is case sensitive

GitHub

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Jira

notified

Scenario > Add module > Jira Software

Add Jira Module

Insert the Jira module that will create bug tickets. This handles the actual ticket creation in your Jira project.

1Click the '+' button after the filter
2Search for 'Jira Software' and select it
3Choose 'Create an Issue' as the action
4Click 'Add' to create a new Jira connection

✓ What you should see: The Jira Software module appears with 'Create an Issue' selected and connection setup ready.

Jira module > Connection > Add

Connect Jira Account

Authenticate with your Jira instance to allow ticket creation. Make supports both Cloud and Server instances.

1Enter your Jira site URL (e.g., yourcompany.atlassian.net)
2Input your Jira email address
3Paste your Jira API token in the API Token field
4Click 'Save' to verify the connection

✓ What you should see: Jira connection shows 'Connected' status and your projects load in the dropdown menus.

⚠

Common mistake — Use an API token, not your Jira password - generate one from Jira Account Settings > Security > API tokens

Jira module > Issue settings

Configure Jira Project Settings

Select the target Jira project and issue type for bug reports. This determines where GitHub bugs land in your Jira workflow.

1Select your target project from the Project dropdown
2Choose 'Bug' as the Issue Type
3Set Summary to map to the GitHub issue title
4Map Description to the GitHub issue body

✓ What you should see: Project and Issue Type fields populate with your selections, and field mapping shows GitHub data sources.

⚠

Common mistake — If 'Bug' doesn't appear in Issue Type, check your Jira project settings - not all projects have bug issue types enabled

Jira module > Field mapping

Map Basic Issue Fields

Connect GitHub issue data to Jira ticket fields. This ensures bug details transfer correctly from GitHub to Jira.

1Set Summary field to GitHub 'title'
2Map Description to GitHub 'body' field
3Set Reporter to your Jira user ID
4Choose 'Medium' as default Priority

✓ What you should see: All required Jira fields show mapped values from GitHub or default settings.

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 module > Advanced settings > Priority

Add Severity Mapping Logic

Create conditional logic to map GitHub labels to Jira priority levels. This routes critical bugs appropriately.

1Click 'Show advanced settings' in the Jira module
2Add a switch condition for Priority field
3Map 'critical' label to 'Highest' priority
4Map 'urgent' label to 'High' priority
5Set default priority to 'Medium'

✓ What you should see: Priority field shows conditional mapping with GitHub labels determining Jira priority values.

⚠

Common mistake — Test with labels that actually exist in your GitHub repo - mapping non-existent labels will default to Medium priority

Scenario > Run once

Test the Scenario

Run a test to verify the workflow processes GitHub bug labels correctly. This catches configuration issues before going live.

1Click 'Run once' at the bottom of the scenario
2Go to GitHub and add a 'bug' label to any issue
3Return to Make and check the execution log
4Verify the Jira ticket was created with correct details

✓ What you should see: Execution log shows successful run with GitHub trigger and Jira ticket creation, plus the new ticket exists in Jira.

⚠

Common mistake — If no execution triggers, check that you labeled the issue AFTER setting up the webhook - existing labels won't trigger retroactively

Drop this into a Make custom function.

JavaScript — Custom Function{{if(contains(map(1.labels; "name"); "critical"); "Highest"; if(contains(map(1.labels; "name"); "urgent"); "High"; "Medium"))}}

▸ Show code

{{if(contains(map(1.labels; "name"); "critical"); "Highest"; if(contains(map(1.labels; "name"); "urgent"); "High"; "Medium"))}}

... expand to see full code

{{if(contains(map(1.labels; "name"); "critical"); "Highest"; if(contains(map(1.labels; "name"); "urgent"); "High"; "Medium"))}}

Make

▶ Run once

executed

✓

GitHub

✓

Jira

🔔 notification

received

Scaling Beyond 200+ bugs/month+ Records

If your volume exceeds 200+ bugs/month records, apply these adjustments.

Add execution delays

Insert 2-3 second delays between operations to avoid hitting Jira's 10 requests/second rate limit. Use Make's sleep module between GitHub fetch and Jira creation.

Implement deduplication

Use Make's data store to track processed GitHub issue IDs. Check the store before creating Jira tickets to prevent duplicates from webhook retries or multiple label additions.

Batch historical imports

If importing existing GitHub issues, use Make's iterator with scheduling to process 50 issues per hour instead of all at once. This prevents API rate limit violations.

Going live

Production Checklist

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

Set error handling to 'Break' to catch Jira API failures

Applies when: Always

Add data store to track processed GitHub issue IDs for deduplication

Applies when: High volume

Test severity mapping with all your GitHub label variants

Applies when: Always

Configure webhook retry settings in GitHub repo for failed deliveries

Applies when: Always

Set up monitoring alerts for scenario execution failures

Applies when: Enterprise

Add rate limiting delays if processing 100+ issues/hour

Applies when: High volume

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 conditional logic for severity mapping or plan to expand the workflow later. Make's visual router system handles GitHub label-to-Jira priority mapping better than Zapier's limited branching. The scenario builder lets you add complexity like checking multiple labels, routing to different Jira projects, or creating Slack notifications. Skip Make if you just want basic bug forwarding without conditions - Zapier's GitHub-Jira integration is simpler for straight pass-through.

Cost

This workflow uses 2 operations per bug report - one for the GitHub trigger and one for Jira ticket creation. At 50 bugs/month, that's 100 operations total. That fits Make's free tier (1,000 ops/month). At 200+ bugs monthly, you'll need the Core plan at $9/month. Zapier charges $20/month for the same volume on their Starter plan, and N8n's cloud costs $20/month for equivalent usage. Make wins on cost until you hit enterprise volume.

Tradeoffs

Zapier's GitHub integration includes more trigger options like issue comments and pull request changes, which Make doesn't offer. N8n provides better error handling with built-in retry logic and detailed error logs that help debug failed Jira API calls. But Make's conditional routing beats both platforms for severity mapping - you can build complex label hierarchies without code, while Zapier requires premium features and N8n needs JavaScript functions.

GitHub's webhook delivery can duplicate events if your internet connection drops during processing, causing duplicate Jira tickets. Make doesn't automatically dedupe based on GitHub issue IDs, so add a data store to track processed issues. Jira's API rate limit is 10 requests/second - if you batch-import historical issues, you'll hit this limit and need iterator delays. GitHub's label webhooks fire immediately, but Jira ticket creation can lag 30+ seconds during high API usage periods.

Ideas for what to build next

→
Add Slack notifications for critical bugs — Send alerts to your on-call channel when high-priority Jira tickets are created from GitHub critical labels.
→
Sync Jira status back to GitHub — Update GitHub issue labels when Jira tickets move to In Progress or Done status to keep both systems aligned.
→
Create assignment routing — Automatically assign Jira tickets to specific team members based on GitHub repository or label combinations.