How To Integrate GitHub and Jira in 12 Minutes or Less

How To Integrate GitHub and Jira in 12 Minutes or Less

Published in Unito on , last updated .

This walkthrough will guide you through the process of connecting GitHub and Jira with Unito, so you can quickly sync issues between a GitHub repository and a Jira project with automated 2-way updates. You’ll learn how to sync GitHub issues with Jira issues to share details on ticket management, development information, deployment information, issue tracking, and more.

We’ll begin with an overview of the integration, how it can be used, then show you how to connect each tool and set rules to determine which issues to sync. Then, you’ll select fields (or details) to keep automatically updated between GitHub and Jira issues. 

New to Unito? Here’s more information about our GitHib Jira integration.

In this article:

Feel free to skip ahead if you’ve already started building your GitHub Jira integration.

By the end of this article, you’ll have a clear, integrated workflow that automatically:

  • Creates new Jira tasks, issues or stories based on activity in your GitHub repositories.
  • Creates new issues in a GitHub repository based on your activity in a Jira project.
  • Updates Jira Cloud and GitHub in either direction automatically whenever manual changes occur.

Note: You must be a GitHub admin or organization owner in order to connect GitHub to Unito. You can find more detailed instructions on adding GitHub to Unito here.

Setup in Jira

Here’s a separate guide on how to connect a local Jira Server on-premise to Unito. You can also connect your server via ngrok.

Here’s how to configure Jira if you aren’t using OAuth2 (click to expand)

There are a few steps involved before we can set up a two-way sync with Unito, but we promise it’s worthwhile. The benefit of eliminating manual tasks for your team indefinitely far outweighs the time it takes to set up your automation rules now. So let’s dive in.

Jira profile page to change email contact visibility
Changing your Jira contact email visibility enables Unito to discover your account and sync Jira issues to GitHub.

Step 1. Get your labels or custom fields organized

The number one piece of advice we offer all new Unito users about building their first flow is this:

Get organized first! Unito syncs work based on rules you provide. But in order to set conditions for your flow, those rules must be based on a certain logic related to your fields. For example, only sync Jira issues with the GitHub label.

You can even use single-select custom fields to apply new rules. Unito’s rules and field mappings adapt to your instances and use case!

Jira fields that can be used to set rules:

  • Assignee
  • Component
  • Epic
  • Fix version
  • Flagged
  • Issue status
  • Issue type
  • Label
  • Priority
  • Sprint

GitHub fields that can be used to set rules

  • Assignee
  • Issue type
  • Label
  • Milestone
List of GitHub fields which can be used to set rules in Unito for 2-way sync

Step 2. Connect Jira and GitHub to Unito

First, connect your GitHub account and Jira Cloud account to Unito. This process involves granting necessary permissions to Unito for accessing your GitHub repositories and Jira instance.

Screenshot of Unito's integration interface showing two columns. On the left, 'Sync work in Jira Cloud' with a drop-down menu for selecting an account, labeled 'Samuel Dixon,' and options to choose the type of issue and project, specifically 'Agile Sprint Board ABC.' On the right, 'Sync work in GitHub' with a similar setup, indicating the account 'HughNeato' and a repository named 'HughNeato/DevOps-Initiative
  1. Log in to the Unito App and click +Create Flow.
  2. Then, click Start Here to connect your tools.
  3. Select +Add a tool to this flow in either column, and connect your apps. Now, +Choose account to specify the account you want to use.
  4. From the next drop-down menu, type in the name of the folder or table you want to connect.
  5. Repeat steps 3 and 4 to connect your other tool with Unito.
  6. Click Confirm.

Connecting GitHub to Unito for the first time

If this is your first time connecting GitHub to Unito, you’ll need a GitHub admin or organization owner to complete a few extra steps to choose which GitHub organization(s) you wish to sync issues from.

Click to expand for GitHub setup instructions
  1. First, you’ll  be prompted to select an organization or your personal GitHub account. Chooes the organization you plan on syncing.
  2. On the next screen, you can choose to sync issues from specific repos within that organization, or issues from all repos. Choose whichever option you prefer.

If you can’t complete this process for any reason, don’t hesitate to reach out to our live support team.

When you’re ready, select Confirm.

Step 2. Pick a direction for new GitHub or Jira issues

Flow direction determines how new issues in GitHub or Jira are created by Unito. 

Later we’ll tell Unito which tasks and issues to keep synced. You can choose to have new GitHub repositories sync with an existing Jira project or vice versa.

Screenshot illustrating the direction of workflow between Jira and GitHub in Unito. It shows a diagram with two icons representing the 'Agile Sprint Board ABC' and 'HughNeato/DevOps-Initiative,' with arrows pointing in both directions, indicating a two-way sync setup

Select Confirm when you’ve chosen a flow direction.

Learn more about flow direction.

Step 3. Set rules to decide which issues to sync between Jira and GitHub

Set up rules to filter which GitHub issues and Jira issues to sync. This step ensures that only relevant data is shared between your GitHub organization and Jira software. If you chose a two-way flow, you’ll have to set rules for both directions.

Select Add a new rule to begin.

You can also remove a rule by selecting the bin icon on the right-hand side.

Screenshot of Unito's rules configuration interface, displaying conditional rules for syncing. It shows rules for when an issue in 'Jira Cloud Agile Sprint Board ABC' with an 'Open' status and 'Story' issue type will sync to 'GitHub HughNeato/DevOps-Initiative,' and vice versa, with different conditions including 'Issue type' is 'Issue' and 'Label' is 'Help wanted.

In the above examples, we’re syncing issues based on common labels and issue type in Jira and GitHub.

You can learn more about setting up rules here.

Here you can choose which details to sync between GitHub and Jira, such as issue tracking information and deployment frequency data. This ensures that updates in pull requests or Jira issue keys are reflected on both platforms.

First, you’ll be asked whether you want to set up your field mappings from scratch or let Unito do this automatically.

Unito's auto mapping table for fields

You can add additional mappings by selecting +Add Mapping, then Select a field in both tools to pair the fields together.

Here’s a look at our auto-mapped fields between GitHub and Jira:

Most fields will automatically be mapped for two-way updates, but you can modify them individually if you prefer one-way updates in some cases.

Screenshot of field mappings in Unito's interface between 'Agile Sprint Board ABC' and 'HughNeato/DevOps-Initiative.' It lists mapped fields including 'Sprint,' 'Issue type,' 'Issue status,' and 'Labels,' among others, with two-way arrows for each, suggesting that updates in one platform will reflect on the other.
With two-way updates, changes made in either tool will automatically update the other. A one-way update restricts changes to a single direction.

Configuring field values in HubSpot and Jira

The gear (or cog) icon indicates configurable fields with additional options to match your use case. In the case of single or multi-select fields (such as labels or status), that means you can modify specific values within that field for additional customization.

Screenshot displaying the mapping of labels in Unito's interface. It shows a 'Labels' section with a two-way arrow, indicating synchronization between labels 'bug' and 'Priority:3' from Jira to GitHub and vice versa. There's also a button to 'Add more labels' for additional synchronization options
Any symbol with a gear icon indicates fields with single-select or multi-select options that can be paired together between GitHub and Jira.

If you don’t configure these fields, then your flow will refer to your default rules when syncing.

You can also append the issue number from GitHub to Jira or Jira to GitHub to help keep track of tickets between tools:

Clicking the toggle above can link our Jira issue number to the GitHub issue or vice versa automatically.

Click Confirm when you’re ready to proceed.

Find out more about setting field mappings.

Step 5. Launch your GitHub Jira integration

Now it’s time to launch your GitHub-Jira integration. This integration facilitates project management, enhances team visibility, and improves deployment information sharing.

If you followed the steps above, your flow will now automatically create new issues in both tools based on specific activity in the other, while keeping paired fields up to date.

Screenshot showing a Jira issue and a GitHub issue side by side, demonstrating a successful sync. The Jira issue is part of the 'Agile Sprint Board ABC' backlog and details 'OAuth 2.0 Implementation for Enhanced Security.' The corresponding GitHub issue in the repository 'HughNeato/DevOps-Initiative' mirrors this with matching labels 'help wanted' and 'Priority 3,' and a comment indicating synchronization by Unito.

If you have any questions, don’t hesitate to reach out and let us know.

GitHub documentation for Unito users

Jira documentation for Unito users

What’s next after connecting GitHub and Jira with Unito?

Now that you’ve set up your integration between Jira and GitHub, you can unify project management and improve cross-team visibility across tools with real time two way updates.  You can also read more about Unito’s integrations for Jira and GitHub to better understand their capabilities and limitations.

Why connect GitHub with Jira?

Connecting these two powerful tools saves time, helps teams and squads collaborate more efficiently, and turns both GitHub and Jira into shared sources of truth.

The end result will be a simple workflow that enables you to automatically create and sync new issues in one repo or project, based on manual changes in the other. This is most useful for: software developers, quality assurance teams, product managers, teams practicing DevOps, customer support, or cybersecurity.

Streamlined collaboration between dev teams

Unito’s 2-way integration eliminates the need to search for specific issues or tasks. Instead, teams can simply stay in their preferred GitHub or Jira interface and watch those work items appear in their projects and repositories.

Facilitate software project management

Unito’s GitHub Jira integration becomes an invaluable asset for project managers juggling multiple teams at once. You can eliminate tool-switching and human error so you can focus on overseeing projects and reporting on progress.

Optimize version control with a united source of truth

One recurring challenge faced by teams in multiple tools is the inevitable data silo that crops up. This can be especially problematic where version control is concerned. Unito simplifies version control between Jira and GitHub by keeping issues synced between each tool in real-time.

Essential Unito features for this use case

Custom fields

Sync custom fields from GitHub to Jira, preserving the uniqueness of your projects.

GitHub uses custom fields to give users more control over their projects. Unito can sync these fields from GitHub to other apps and back so you don’t lose any customizability. Unito’s pricing page has all the details on how many custom fields can by synced according to your plan.

Advanced mappings

For many integration solutions, you’re a bit stuck with what the tools give you. That makes it tough to truly recreate the environment from one tool in the other. Unito lets you customize your field mappings so that isn’t the case. When you’re using a flexible tool like Notion, that’s essential.

Smart Commits: Use smart commits to link commit messages directly to Jira issues, automating status updates and work logs.

Repository Selection: Choose specific repositories for integration, maintaining relevance to your current project management needs.

FAQ

Does Unito access my GitHub code repositories?

How does the GitHub-Jira integration improve project management for software development teams?

By linking GitHub repositories to Jira projects, teams can automate the tracking of code changes, pull requests, smart commits, and issue resolution, enhancing collaboration and efficiency.

Can I integrate multiple GitHub organizations with a single Jira instance?

Yes, this integration works to enable any GitHub repository to connect with a Jira instance, enabling you to manage several projects and teams within a single Jira Cloud account.

How do I ensure that only relevant issues are synced between GitHub and Jira?

You can set up rules and filters based on labels, issue keys, or other criteria to ensure that only pertinent GitHub issues from a new repository and Jira issues are synchronized.

How does the integration automatically sync deployment information between GitHub and Jira?

Integrating Jira with your GitHub organization leverages real-time syncing to automatically update deployment information in both tools. When a new deployment occurs in GitHub, the corresponding issue in Jira is updated with this information, and vice versa, ensuring both repositories are always in sync.

Can I add more apps to the GitHub-Jira integration with Unito, and how does that work?

Yes, you can configure the integration to include other project management or development tools, even additional Jira accounts, creating a comprehensive ecosystem that automatically works together, ensuring seamless data flow and collaboration across all platforms.

How do I configure the integration to include branch names in Jira issues?

To include branch names in Jira issues, you’ll need to configure the field mappings in Unito when you integrate GitHub. This involves specifying that the branch name in a GitHub repository should be synced with a custom field in the Jira issue. This setup ensures that team members can see relevant branch names directly within Jira, enhancing clarity and traceability.

What is the significance of the issue key in syncing repositories, and how is it used?

The issue key is a critical component in syncing repositories as it serves as a unique identifier for issues after you integrate Jira. So, when connected GitHub, the issue key can be used to link commits, pull requests, and branch names directly to the corresponding Jira issue, automating the tracking of changes and facilitating easier navigation between the two platforms.

How does adding comments in GitHub affect the Jira issue, and is this updated automatically?

Adding comments in GitHub to issues or pull requests that are linked to a Jira issue will automatically update the corresponding Jira issue with these comments. And so, this ensures that all discussions related to an issue are consolidated and accessible in both tools, fostering better communication and collaboration.

Can the integration help reduce cycle time by automatically updating issues across platforms?

By ensuring that updates, such as status changes or new comments, are automatically reflected across both GitHub and Jira, the integration helps in reducing the cycle time.

It minimizes the need for manual updates and checks in Jira server or GitHub cloud, streamlining the workflow and helping teams to move faster from development to deployment.

Who should sync GitHub and Jira with Unito?

Imagine a software development team working on a new feature for their product or application. The team might use GitHub for code repository management, pull requests, version control, and tracking code-related issues.

Meanwhile, a project management tool such as Jira software, on the other hand, might be used for sprint planning or tracking non-code related work.

The biggest differentiator is the power of real-time 2-way updates between issues in Jira and GitHub. No native integration can keep your Jira tasks or issues in sync with a GitHub repository in real-time. So, while it is possible to simulate 2-way sync with a series of complex automations and other platforms, only Unito was built to achieve this quickly and easily for users of all backgrounds and experience.

So, once you integrate Jira and integrate GitHub with Unito, your development teams will be able to manage code and project tasks in a unified system, streamlining sprint methodologies and agile processes. Pull requests in GitHub can be linked to tasks in Jira Software, providing a comprehensive view of project management efforts.

A GitHub issue synced to a Jira issue with Unito's 2-way sync

B