Can I sync existing GitHub issues or only new ones?

This webhook setup only catches new issues going forward. To sync existing issues, add a GitHub node with 'Get All Issues' operation as a separate workflow branch.

What happens if the same GitHub issue triggers multiple webhooks?

GitHub retries failed webhooks up to 5 times, which creates duplicate Jira tickets. Add a duplicate check using Jira's search API before creating new tickets.

Do GitHub issue updates sync back to Jira automatically?

No, this workflow only handles issue creation. You need separate webhooks for 'edited' and 'closed' actions to sync updates and status changes.

Can I filter which GitHub repositories trigger the webhook?

Set up separate webhooks per repository or add an IF node checking the repository name from the webhook payload before creating Jira tickets.

How do I handle GitHub issues that should become different Jira issue types?

Add logic to check GitHub labels like 'bug' or 'feature' and map them to corresponding Jira issue types using a Switch node before the Jira creation step.

Intermediate~20 min setupDeveloper Tools & Project ManagementVerified April 2026

How to Sync GitHub Issues to Jira Tickets with N8n

Auto-create Jira tickets when GitHub issues are opened, mapping title, description, labels, and assignee between platforms.

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

n8n

Also on:Make Zapier Power-automate Pipedream

Best for

Dev teams who need custom field mapping between GitHub issues and Jira tickets with real-time sync.

Not ideal for

Teams wanting plug-and-play setup without webhook configuration or custom field transformation logic.

Sync type

real-time

Use case type

sync

Real-World Example

💡

A 12-person mobile app team uses this to automatically create Jira tickets for every GitHub issue in their bug-tracker repo. Before automation, the project manager manually checked GitHub twice daily and created Jira tickets by copy-pasting, missing critical bugs for hours. Now customer-reported issues flow from GitHub to their sprint board instantly, with proper labels and assignees mapped.

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 n8n

Copy the pre-built n8n blueprint and paste it straight into n8n. 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.

Admin access to the GitHub repository where you want to sync issues

Jira administrator permissions to create API tokens and tickets

N8n instance running (cloud or self-hosted) with internet-accessible webhook URLs

Optional

GitHub and Jira user accounts that match for assignee mapping

Field Mapping

Map these fields between your apps.

Field	API Name	Description
Required
Issue Title	`issue.title`	GitHub issue title maps directly to Jira ticket summary field

5 optional fields▸ show

Issue Description	`issue.body`	GitHub issue body becomes Jira description, with original GitHub URL appended
Assignee	`issue.assignee.login`	GitHub username maps to Jira assignee if the user exists in both systems
Labels	`issue.labels[].name`	Array of GitHub label names converted to comma-separated Jira labels
Issue Number	`issue.number`	GitHub issue ID stored in Jira custom field for reverse lookup
Repository	`repository.name`	Source GitHub repo name added to Jira ticket for multi-repo tracking

Step-by-Step Setup

Dashboard > New Workflow

Create new workflow

Start a fresh N8n workflow to handle the GitHub to Jira sync. This sets up the canvas where you'll build the automation.

1Click 'New Workflow' from the N8n dashboard
2Name it 'GitHub-Jira Issue Sync'
3Click 'Save' to create the workflow

✓ What you should see: You should see an empty workflow canvas with a placeholder start node.

Workflow Canvas > Add Node > Webhook

Add GitHub webhook trigger

Set up N8n to receive webhook notifications when GitHub issues are created. This replaces polling and gives you real-time sync.

1Click the '+' button to add a trigger node
2Search for 'Webhook' and select it
3Set HTTP Method to 'POST'
4Copy the webhook URL that N8n generates

✓ What you should see: You should see a webhook node with a unique URL ending in /webhook/github-issues.

⚠

Common mistake — Don't use the GitHub trigger node - it polls every 5 minutes instead of real-time webhooks.

n8n

click +

search apps

GitHub

Add GitHub webhook trigger

GitHub

module added

GitHub Repo > Settings > Webhooks

Configure GitHub webhook

Tell GitHub to send issue events to your N8n webhook. This creates the connection between GitHub and your automation.

1Go to your GitHub repository settings
2Click 'Webhooks' in the left sidebar
3Click 'Add webhook'
4Paste your N8n webhook URL
5Select 'Issues' as the trigger event
6Set Content type to 'application/json'

✓ What you should see: GitHub shows a green checkmark next to your webhook after the first successful delivery.

⚠

Common mistake — Don't select 'Send me everything' - this floods N8n with comments, labels, and other events you don't need.

Workflow Canvas > Add Node > IF

Add issue filter

Filter webhook events to only process new issues. GitHub sends webhooks for issue updates, closes, and comments too.

1Add an 'IF' node after your webhook
2Set condition to 'String' equals
3Set field to '{{ $json.action }}'
4Set value to 'opened'

✓ What you should see: The IF node shows 'true' branch and 'false' branch connections.

⚠

Common mistake — Without this filter, you'll create duplicate Jira tickets for every issue comment and status change.

GitHub

trigger

filter

Condition

matches criteria?

yes — passes through

no — skipped

Jira

notified

Credentials > Create New > Jira

Connect Jira credentials

Set up authentication so N8n can create tickets in your Jira instance. You need API access to write to Jira.

1Click 'Credentials' in the N8n sidebar
2Click 'Create New' > 'Jira Software Cloud API'
3Enter your Jira domain (company.atlassian.net)
4Add your email and API token
5Test the connection

✓ What you should see: You should see 'Connection successful' with your Jira instance details.

⚠

Common mistake — Use an API token, not your password - Jira blocks basic auth for automation.

Workflow Canvas > Add Node > Jira

Add Jira create issue node

This node creates the actual Jira ticket using data from the GitHub webhook. Connect it to the 'true' branch of your filter.

1Add a 'Jira' node after the IF node's true branch
2Select your Jira credentials
3Choose 'Issue' > 'Create' operation
4Select your target project from the dropdown

✓ What you should see: The Jira node shows your project name and available issue types like 'Bug' and 'Task'.

Jira Node > Issue Fields

Map issue title and description

Pull the GitHub issue title and body into the Jira ticket fields. This ensures all context transfers between systems.

1Set Summary field to '{{ $node.Webhook.json.issue.title }}'
2Set Description to '{{ $node.Webhook.json.issue.body }}'
3Add a line 'GitHub URL: {{ $node.Webhook.json.issue.html_url }}' to description

✓ What you should see: You should see the mapped expressions in the Summary and Description fields.

⚠

Common mistake — GitHub description can be empty - add a null check or default text to avoid blank Jira tickets.

Drop this into an n8n Code node.

Copy this template{{ $node.Webhook.json.issue.labels.length > 0 ? $node.Webhook.json.issue.labels.map(l => l.name.replace(/\s+/g, '_').toLowerCase()).join(',') : 'unlabeled' }}

▸ Show code

{{ $node.Webhook.json.issue.labels.length > 0 ? $node.Webhook.json.issue.labels.map(l => l.name.replace(/\s+/g, '_').toLowerCase()).join(',') : 'unlabeled' }}

... expand to see full code

{{ $node.Webhook.json.issue.labels.length > 0 ? $node.Webhook.json.issue.labels.map(l => l.name.replace(/\s+/g, '_').toLowerCase()).join(',') : 'unlabeled' }}

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

Workflow Canvas > Add Node > Set

Handle GitHub labels

Convert GitHub labels into Jira labels or components. This preserves categorization across platforms.

1Add a 'Set' node before the Jira node
2Create a new field called 'jira_labels'
3Use expression '{{ $node.Webhook.json.issue.labels.map(l => l.name).join(",") }}'
4Reference this in Jira node Labels field

✓ What you should see: The Set node shows your label transformation logic with sample output.

⚠

Common mistake — Jira labels can't have spaces - replace spaces with underscores or map to custom fields instead.

Jira Node > Assignee Field

Map GitHub assignee

Transfer the GitHub issue assignee to Jira if they exist in both systems. This maintains ownership tracking.

1In the Jira node, find the Assignee field
2Set it to '{{ $node.Webhook.json.issue.assignee.login }}'
3Add a fallback using '|| "unassigned"'
4Test with a real GitHub issue that has an assignee

✓ What you should see: The Assignee field shows the mapped GitHub username with fallback logic.

⚠

Common mistake — GitHub usernames don't always match Jira usernames - you may need a lookup table for name mapping.

Workflow Canvas > Execute Workflow

Test the workflow

Run a live test by creating a new GitHub issue. This validates your entire automation chain.

1Click 'Execute Workflow' to activate listening mode
2Create a new issue in your GitHub repository
3Check the N8n execution log for success
4Verify the Jira ticket was created with correct data

✓ What you should see: N8n shows green checkmarks on all nodes and a new Jira ticket appears with GitHub data.

⚠

Common mistake — First webhook delivery can take 30-60 seconds - don't assume it's broken if you don't see immediate results.

n8n

▶ Run once

executed

✓

GitHub

✓

Jira

🔔 notification

received

Workflow Settings > Error Workflow

Add error handling

Configure what happens when Jira is down or fields are invalid. This prevents the workflow from silently failing.

1Click workflow settings (gear icon)
2Set 'On Error' to 'Continue With Default Value'
3Add a 'No Operation' node after Jira for the error branch
4Test by temporarily breaking your Jira credentials

✓ What you should see: Failed executions show error details but don't stop the workflow entirely.

⚠

Common mistake — Don't use 'Ignore' error handling - you'll miss failed syncs and create data gaps.

Workflow Canvas > Activate Toggle

Activate workflow

Turn on the workflow so it runs automatically for all new GitHub issues. This makes the automation live.

1Click the toggle switch in the top right to 'Active'
2Verify the webhook is still responding
3Create one more test GitHub issue to confirm
4Monitor the execution history for the first few runs

✓ What you should see: The workflow shows 'Active' status and processes new GitHub issues automatically.

Scaling Beyond 100+ issues/day+ Records

If your volume exceeds 100+ issues/day records, apply these adjustments.

Add webhook queue

Use N8n's HTTP Request node with retry logic instead of direct Jira calls. GitHub webhooks timeout at 10 seconds, but Jira API can be slower.

Batch label processing

Group multiple label operations into single Jira API calls using N8n's merge node. Individual label updates hit rate limits fast.

Cache user mappings

Store GitHub-to-Jira username mappings in N8n's global variables instead of looking up users on every issue. API calls for user validation add 2-3 seconds per ticket.

Going live

Production Checklist

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

Test webhook delivery with GitHub's webhook delivery history

Applies when: Always

Set workflow error handling to 'Continue' not 'Stop Workflow'

Applies when: Always

Add rate limit handling for Jira API (10 requests per second max)

Applies when: High volume

Create fallback assignee when GitHub user doesn't exist in Jira

Applies when: Always

Verify Jira project permissions for the API token user

Applies when: Always

Monitor execution history for webhook timeout failures

Applies when: Always

Troubleshooting

Common errors and how to fix them.

Frequently Asked Questions

Common questions about this workflow.

Analysis

VerdictWhy n8n for this workflow

Use N8n for this if you need custom field transformations or run on-premise infrastructure. N8n's code nodes let you manipulate GitHub webhook data before sending to Jira - useful when you need to map labels to custom fields or transform markdown to Jira syntax. The self-hosted option keeps sensitive issue data within your network. Skip N8n if you want the fastest setup - Zapier's GitHub/Jira templates work in 5 minutes versus N8n's 30-minute webhook configuration.

Cost

This workflow uses 1 execution per new GitHub issue. At 50 issues per month, that's 50 executions total. N8n's starter plan includes 5,000 executions for $20/month, so you're well within limits. Zapier charges $20/month for 750 tasks but counts each field mapping as separate tasks - this same workflow burns 4-5 Zaps per issue. Make offers 10,000 operations for $9/month but webhook delays can hit 2-3 minutes. N8n processes webhooks under 10 seconds.

Tradeoffs

Zapier wins on the pre-built GitHub/Jira integration - it maps issue types and custom fields automatically without manual configuration. Make handles GitHub's nested label arrays more elegantly with built-in iterators. N8n makes you build these transformations from scratch using Set nodes and expressions. But N8n's webhook triggers are more reliable than Zapier's polling, and you're not locked into someone else's field mapping decisions when your Jira setup gets complex.

GitHub's webhook payload changes between issue types - pull requests include different fields than regular issues. Your IF filter needs to check both action type and issue type to avoid errors. Jira's user lookup is case-sensitive, so GitHub usernames with capital letters won't match Jira accounts automatically. The biggest gotcha: GitHub sends webhook retries if N8n doesn't respond within 10 seconds, so slow Jira API calls create duplicate tickets. Add timeout handling to your Jira nodes.

Ideas for what to build next

→
Add bidirectional comment sync — Set up webhooks to sync comments between GitHub issues and Jira tickets, keeping discussions in both platforms.
→
Create status update automation — Build a reverse sync that updates GitHub issue labels when Jira ticket status changes from To Do to Done.
→
Add Slack notifications — Extend the workflow to post new issue alerts in your dev team's Slack channel with links to both GitHub and Jira.