Can I sync existing GitHub issues or only new ones?

Make's GitHub trigger only catches new issues created after activation. To sync existing issues, create a separate scenario using the 'Search Issues' module and run it once manually.

What happens if the GitHub webhook fails?

GitHub retries webhook deliveries up to 5 times over 8 hours. If all retries fail, you'll miss that issue sync. Check your scenario error logs and GitHub webhook delivery logs to diagnose connection problems.

Can I sync issue comments and updates too?

Yes, but you'll need separate scenarios for 'Watch Issue Comments' and 'Watch Issues' with 'updated' action. Each comment sync uses additional operations, so monitor your usage closely with active repositories.

How do I handle custom Jira fields?

Custom fields appear in the Jira module after you select your project. Map them to GitHub fields or set static default values. Required custom fields will break the scenario if left empty.

Can I filter which GitHub issues get synced?

Add a Filter module between GitHub and Jira using conditions like label names, assignee, or title keywords. This prevents test issues or specific categories from cluttering your Jira project.

Beginner~12 min setupDeveloper Tools & Project ManagementVerified April 2026

How to Sync GitHub Issues to Jira Tickets with Make

Automatically create Jira tickets when GitHub issues are opened, mapping title, description, labels, and assignee across platforms.

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 creating 50+ GitHub issues monthly who need automatic Jira ticket creation with field mapping.

Not ideal for

Teams with under 20 issues per month or those requiring complex business logic beyond basic field mapping.

Sync type

real-time

Use case type

sync

Real-World Example

💡

A 12-person SaaS development team uses this to automatically create Jira tickets for every GitHub issue, ensuring nothing falls through cracks during sprint planning. Before automation, developers manually copied issue details to Jira twice weekly, often missing critical bugs reported over weekends. Now support tickets become trackable Jira stories within 30 seconds of GitHub creation.

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 or write access for webhook creation

Jira project with Create Issues permission

Jira API token (generated from Account Settings > Security)

Make account with available operations on your plan

Optional

Matching usernames between GitHub and Jira for assignee mapping

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Issue Title	`title`	Maps directly to Jira Summary field — keep under 255 characters
Issue Description	`body`	GitHub issue body content mapped to Jira Description with Markdown formatting preserved
Issue Number	`number`	GitHub issue number for tracking and duplicate prevention

5 optional fields▸ show

Assignee	`assignee.login`	GitHub username that must match existing Jira user account exactly
Labels	`labels[].name`	Array of GitHub label names — requires processing to remove spaces for Jira compatibility
Repository Name	`repository.name`	Source repository identifier useful for multi-repo Jira projects
Created Date	`created_at`	Issue creation timestamp for audit trails and reporting
Issue URL	`html_url`	Direct link to GitHub issue for easy reference in Jira comments

Step-by-Step Setup

Scenarios > Create new scenario > GitHub > Watch Issues

Create new scenario

Set up a new Make scenario to monitor GitHub for new issues. This will be the foundation that triggers whenever someone creates an issue in your repository.

1Click 'Create a new scenario' from your Make dashboard
2Click the large + button in the center
3Search for 'GitHub' and select it from the app list
4Choose 'Watch Issues' as your trigger module

✓ What you should see: You should see a GitHub module with 'Watch Issues' selected as the first step in your scenario.

GitHub Module > Connection > Add

Connect GitHub account

Authenticate your GitHub account and select the repository to monitor. Make needs read access to watch for new issues and pull issue data.

1Click 'Add' next to the Connection field
2Select 'GitHub' connection type
3Click 'Sign in with GitHub' and authorize Make
4Enter a connection name like 'GitHub Main Account'

✓ What you should see: A green checkmark appears next to your connection name, indicating successful authentication.

⚠

Common mistake — Make sure you have admin or write access to the repository — read-only access won't work for webhook creation.

Make settings

Connection

Choose a connection…Add

click Add

GitHub

Authorize Make

popup window

✓

Connected

green checkmark

GitHub Module > Repository Settings

Configure repository settings

Select which repository to monitor and set up the webhook. Make will create a webhook in your GitHub repo to receive real-time notifications.

1Select your repository from the 'Repository' dropdown
2Set 'State' to 'Open' to only trigger on new issues
3Leave 'Labels' and 'Assignee' empty to catch all issues
4Click 'OK' to save the module settings

✓ What you should see: The module shows your repository name and 'State: Open' in the configuration summary.

⚠

Common mistake — Don't select 'All' for State — this triggers on every issue update and will create duplicate Jira tickets.

Scenario > Add Module > Jira Software > Create an Issue

Add Jira module

Add the Jira module that will create tickets. This module will receive data from GitHub and transform it into Jira's required format.

1Click the + button after the GitHub module
2Search for 'Jira Software' and select it
3Choose 'Create an Issue' from the action list
4Click 'OK' to add the module

✓ What you should see: A Jira module appears connected to your GitHub module with 'Create an Issue' selected.

Jira Module > Connection > Add

Connect Jira account

Authenticate with Jira and grant Make permission to create issues. You'll need an API token from your Jira account settings.

1Click 'Add' next to the Jira Connection field
2Enter your Jira domain (yourcompany.atlassian.net)
3Enter your email address
4Paste your Jira API token in the password field

✓ What you should see: Connection shows 'Verified' status with your Jira domain displayed.

⚠

Common mistake — Use an API token, not your password — regular passwords won't work with Jira's API authentication.

Jira Module > Project Settings

Select Jira project

Choose which Jira project will receive the new tickets. The project determines available issue types and required fields for ticket creation.

1Select your target project from the 'Project' dropdown
2Choose 'Task' or 'Bug' as the Issue Type
3Verify the issue type matches your team's GitHub workflow
4Note which fields show as required (marked with *)

✓ What you should see: Project name appears in the dropdown and required fields are highlighted in the form below.

⚠

Common mistake — Check your Jira project permissions — Make needs 'Create Issues' permission in the selected project.

Jira Module > Issue Fields > Summary/Description

Map issue title and description

Connect GitHub issue data to Jira fields. The title and description are core fields that provide context for your development team.

1Click in the 'Summary' field and select 'Title' from GitHub data
2Click in the 'Description' field and select 'Body' from GitHub data
3Add 'GitHub Issue #' before the title using the 'Number' field
4Test the mapping by clicking 'Choose where to start'

✓ What you should see: Summary shows '{{1.title}}' and Description shows '{{1.body}}' with GitHub data variables.

Drop this into a Make custom function.

JavaScript — Custom Function{{if(1.assignee.login; 1.assignee.login; "unassigned-backlog")}}

▸ Show code

{{if(1.assignee.login; 1.assignee.login; "unassigned-backlog")}}

... expand to see full code

{{if(1.assignee.login; 1.assignee.login; "unassigned-backlog")}}

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 > Issue Fields > Assignee

Map assignee field

Connect the GitHub issue assignee to the Jira assignee field. This ensures the right person gets notified in Jira when issues are created.

1Click in the 'Assignee' field
2Select 'Assignee > Login' from the GitHub data
3Add a fallback assignee in case GitHub issue is unassigned
4Enter a default Jira username or leave empty

✓ What you should see: Assignee field shows '{{1.assignee.login}}' with your fallback option configured.

⚠

Common mistake — GitHub usernames must match Jira usernames exactly — mismatches will cause the scenario to fail.

Jira Module > Issue Fields > Labels

Handle GitHub labels

Transform GitHub labels into Jira labels or components. Labels help categorize and filter issues in both systems consistently.

1Click in the 'Labels' field
2Select 'Labels' from the GitHub data
3Click the toggle for 'Map' to enable array processing
4Map 'Labels > Name' to extract label text

✓ What you should see: Labels field shows '{{1.labels[].name}}' indicating it will process the array of label names.

⚠

Common mistake — Jira labels can't contain spaces or special characters — GitHub labels with spaces will cause errors.

Scenario > Run once

Test the scenario

Run a test to verify the integration works correctly. This creates a real Jira ticket from sample GitHub data to validate your field mapping.

1Click 'Run once' at the bottom of the screen
2Wait for the scenario to complete (usually 10-15 seconds)
3Check the execution log for any errors
4Verify a new ticket was created in your Jira project

✓ What you should see: Execution log shows green checkmarks for both modules, and a new Jira ticket appears with GitHub data.

⚠

Common mistake — The test creates a real Jira ticket — delete it after testing or use a test project to avoid cluttering your backlog.

Make

▶ Run once

executed

✓

GitHub

✓

Jira

🔔 notification

received

Jira Module > Right-click > Add error handler

Configure error handling

Set up error handling to manage failed API calls and data issues. This prevents the entire scenario from breaking when individual issues fail to sync.

1Right-click the Jira module
2Select 'Add error handler'
3Choose 'Break' to stop processing that specific issue
4Add an email notification module to alert you of failures

✓ What you should see: A dotted line appears from the Jira module to an error handler with your chosen action.

Scenario > Activate Toggle

Activate the scenario

Turn on the scenario to start monitoring GitHub issues in real-time. Make will create a webhook in your GitHub repository for instant notifications.

1Click the 'ON' toggle in the bottom left
2Confirm you want to activate the scenario
3Check that the scheduling shows 'Instantly'
4Create a test GitHub issue to verify it works

✓ What you should see: Scenario status shows 'ON' and new GitHub issues automatically create Jira tickets within 30 seconds.

⚠

Common mistake — GitHub webhooks can take 2-3 minutes to activate — don't panic if your first test issue doesn't sync immediately.

Scaling Beyond 200+ issues/month+ Records

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

Batch processing for labels

Use an Array Iterator module to process GitHub labels in batches rather than individual API calls. This reduces operations from 1 per label to 1 per issue, saving 60-70% on operation usage for heavily labeled issues.

Webhook retry handling

Add a 2-minute delay module before Jira creation during high-traffic periods. GitHub sometimes sends duplicate webhooks within 30 seconds, and the delay helps your duplicate detection catch them before creating extra tickets.

Operation monitoring

Set up a monthly report scenario that tracks operations used per repository. This helps identify which repos generate the most sync volume and whether you need to upgrade your Make plan or filter certain issue types.

Going live

Production Checklist

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

Set error handling to 'Break' on the Jira module to prevent failed issues from blocking the entire queue

Applies when: Always

Add duplicate detection using GitHub issue number to prevent webhook retry storms from creating multiple tickets

Applies when: Always

Configure email notifications for scenario failures to catch authentication or permission issues quickly

Applies when: Always

Test with actual team GitHub usernames to verify Jira assignee mapping works before going live

Applies when: Always

Set up operation usage alerts at 80% of your monthly limit to avoid scenario shutdowns mid-month

Applies when: High volume

Create a separate Make organization for production scenarios to isolate from development testing

Applies when: Enterprise

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 your team creates 20+ GitHub issues per week and needs them tracked in Jira without manual copying. Make's webhook triggers fire within 30 seconds of issue creation, and the visual builder makes field mapping obvious when you're dealing with custom Jira fields. Skip Make if you only sync a few issues per month — Zapier's simpler interface works better for low-volume scenarios where you won't hit operation limits.

Cost

This workflow uses 2 operations per GitHub issue (1 for the trigger, 1 for Jira creation). At 100 issues per month, that's 200 operations total. Make's Core plan at $9/month includes 10,000 operations, so you're well covered. Zapier would cost $20/month for their Starter plan to handle the same volume. N8N self-hosted is free but requires server management — Make saves you $50+/month in hosting costs.

Tradeoffs

Zapier handles GitHub label formatting better — their built-in formatter automatically converts spaces to hyphens for Jira compatibility. N8N offers more advanced data transformation with JavaScript functions, letting you create complex GitHub-to-Jira username mappings without external tools. Make still wins because its error handling is more granular — you can retry failed syncs without reprocessing successful ones, which matters when you're syncing dozens of issues daily.

GitHub's webhook system occasionally delivers duplicate events during API hiccups, creating duplicate Jira tickets. Add a duplicate detection filter using GitHub issue numbers to catch repeats. Jira's API rate limit kicks in at 300 requests per hour per user — if your team creates issues in bursts, you'll hit 429 errors. The built-in retry mechanism handles this, but expect 5-10 minute delays during peak usage.

Ideas for what to build next

→
Add comment syncing — Create a second scenario that watches GitHub issue comments and posts them to the corresponding Jira ticket using the GitHub issue number for matching.
→
Set up status mirroring — Build a reverse sync that updates GitHub issue labels when Jira ticket status changes, keeping both systems in sync for project status tracking.
→
Create summary reporting — Build a weekly scenario that counts issues synced per repository and emails a summary to your team lead for volume monitoring and process improvement.