Jigit - GitHub, GitLab, Azure DevOps integration for Jira
Auto Light Dark
Auto Light Dark

Jigit - Cloud Configuration

Jigit Cloud connects GitHub, GitLab, and Gerrit to Jira, surfacing pull requests, branches, and code reviews directly on Jira issues. This guide explains how to install and configure these integrations on Jira Cloud.

Admin access required. You must be a Jira Administrator or Site Administrator to configure Jigit. Access the admin page via Jira Administration > Apps > Jigit.


Installing Jigit

  1. Go to the Jigit listing on the Atlassian Marketplace.

  2. Click Try it free.

  3. Select your Jira Cloud site.

  4. Click Review, then Start free trial.

Admin page overview

image-20260624-022510.png

The Jigit admin page has four tabs:

Tab

Purpose

Gerrit

Add and manage Gerrit Code Review server connections. Linked changes appear in the Gerrit tab in the Jira issue Activity section.

Integrations

Add and manage GitHub and GitLab integrations (organisation/group or single repository/project). Pull requests (and GitLab merge requests) and branches appear in the Jigit Development panel on Jira issues.

Settings

Global settings including Jira project scope, branch naming patterns, user authentication strategy, and Git webhooks.

Migration

Import a configuration export from Jigit Data Center. See the Jigit - Migrating from Data Center to Cloud.


Configuring Gerrit

Each Gerrit configuration connects Jigit to one Gerrit server. You can add multiple configurations for different servers or environments. Jigit searches Gerrit for issue keys each time a Jira issue is opened - changes are fetched on demand rather than pre-indexed.

Adding a Gerrit configuration

image-20260321-032751.png
  1. Navigate to Jira Administration > Apps > Jigit > Gerrit.

  2. Click Add configuration.

  3. Complete the configuration form (see field reference below).

  4. Click Test connection to confirm Jigit can reach the Gerrit server using the credentials provided.

  5. Click Create.

image-20260321-033520.png

Gerrit configuration fields

Field

Required

Description

Configuration name

Yes

A label to identify this configuration in the admin UI, for example Production Gerrit.

Gerrit URL

Yes

The base URL of your Gerrit instance, for example https://gerrit.example.com. Must start with http:// or https://. Do not include a path or query string.

Username

No

The Gerrit account username for HTTP Basic authentication. Leave blank for anonymous access to a public Gerrit instance.

Password

No

The HTTP password for the Gerrit account. Generate this in Gerrit via Settings > HTTP Credentials. This is not the same as your Gerrit login password. Required if a username is provided.

Included Jira spaces

No

Limits this configuration to specific Jira project keys. If empty, all projects are included. Cannot overlap with Excluded Jira projects.

Excluded Jira spaces

No

Prevents this configuration from running for specific Jira project keys. Cannot overlap with Included Jira projects.

Search for issue in

No

Selects where Jigit looks for the Jira issue key within a Gerrit change. Choose one or more: Commit (commit message), Topic (topic field - uses Topic Pattern), Branch (target branch name), Comment (change comments). Defaults to commit messages if nothing is selected.

Topic pattern

No

A regex applied to the Gerrit topic field when Topic is selected above. Use {ISSUE_KEY} as a placeholder for the Jira issue key. Default: ^.*{ISSUE_KEY}.*. Example: ^feature/{ISSUE_KEY}$ matches topics like feature/PROJ-123.

Load batch size

No

Maximum number of Gerrit changes fetched per request when displaying linked reviews on a Jira issue.

Viewing Gerrit code reviews in Jira

  1. Open a Jira issue.

  2. Scroll to the Activity section.

  3. Select the Gerrit tab.

  4. Linked changes are listed per configuration, showing the change subject, status (Open, Merged, Abandoned), and reviewer votes.

image-20260331-182141.png

If the Gerrit tab does not appear, check that at least one Gerrit configuration is active and that the Jira project is within scope (not in the configuration's Excluded Jira projects list).


Configuring GitHub (Integrations tab)

Choosing a GitHub host

Jigit Cloud can connect to GitHub.com, a GitHub Enterprise Cloud organization, or a GitHub Enterprise Server you host yourself. Enter the matching address in Base URL when adding the integration:

YOUR GITHUB

BASE URL TO ENTER

GitHub.com

https://github.com

GitHub Enterprise Cloud (data residency)

e.g. https://acme.ghe.com

GitHub Enterprise Server (self-hosted)

e.g. https://github.example.com

Use the web address, not an API address - api.github.com and api.<org>.ghe.com aren't accepted here. The address can't include a path: a pasted link to a specific org or repo will be rejected, since both Enterprise Cloud and Enterprise Server are always served from the host root.

A GitHub Enterprise Server release from 3.9 or later is recommended; older versions may still work but aren't tested against.

Authentication types

Auth type

How it works

Best for

Personal Access Token (PAT)

A GitHub PAT is stored securely and used for all API calls on behalf of the token owner.

Simple setup. Suitable for smaller teams or when a GitHub App is not available.

GitHub App

Jigit uses the App private key to generate short-lived installation tokens automatically. Tokens are cached and refreshed without manual intervention.

Recommended for organisations. Higher API rate limits, granular permissions, and no dependency on an individual user account.

Integration types

Type

Path format

What Jigit indexes

Organisation

my-org

All (or selected) repositories in the organisation account. New repositories can be picked up automatically.

Single repository

my-org/my-repo

One specific repository only.

Adding a GitHub integration with a Personal Access Token

Step 1: Create a GitHub Personal Access Token

  1. In GitHub, go to Settings > Developer settings > Personal access tokens.

  2. Generate a new token (classic or fine-grained).

  3. For a classic PAT, grant: repo (or public_repo for public repositories only) and read:org (required for Organisation integrations).

  4. For a fine-grained PAT, grant Read access to: Contents, Pull requests, Metadata.

  5. Copy the token.

Step 2: Add the integration in Jigit

  1. Navigate to Jira Administration > Apps > Jigit > Integrations.

  2. Click Add integration.

  3. Set Authentication type to Personal Access Token.

  4. Complete the configuration fields (see field reference below).

  5. Paste the PAT into the Personal access token field.

  6. Click Test connection.

  7. Click Create.

image-20260624-025040.png

Adding a GitHub integration with a GitHub App

Step 1: Create and install a GitHub App

  1. In GitHub, go to your organisation or personal Settings > Developer settings > GitHub Apps.

  2. Click New GitHub App.

  3. Configure the app:

    • Name: any descriptive name, for example Jigit Integration

    • Homepage URL: your Jira site URL

    • Webhook: disabled unless enabling webhook support

    • Repository permissions: Contents (Read-only), Metadata (Read-only), Pull requests (Read-only)

  4. Click Create GitHub App.

  5. Note the App ID shown on the app settings page.

  6. Under Private keys, click Generate a private key. Save the downloaded .pem file.

  7. Click Install App and install it on your organisation or selected repositories.

Step 2: Add the integration in Jigit

  1. Navigate to Jira Administration > Apps > Jigit > Integrations.

  2. Click Add integration.

  3. Set Authentication type to GitHub App.

  4. Complete the configuration fields (see field reference below).

  5. Enter the App ID from the GitHub App settings page.

  6. Paste the full contents of the .pem file into the Private key field.

  7. Click Test connection.

  8. Click Create.

image-20260624-025416.png

GitHub App installation tokens are short-lived and refreshed automatically by Jigit. You do not need to rotate them manually.


Configuring GitLab (Integrations tab)

Choosing a GitLab host

YOUR GITLAB

BASE URL TO ENTER

GitLab.com

https://gitlab.com

Self-managed GitLab

e.g. https://gitlab.example.com

Self-managed GitLab installed under a sub-path

e.g. https://example.com/gitlab

Jigit talks to GitLab's API v4. GitLab 8 and earlier only offer API v3 and aren't supported.

Authentication

GitLab integrations use a Personal Access Token only - there is no GitLab equivalent of the GitHub App auth type.

Integration types

TYPE

PATH FORMAT

WHAT JIGIT INDEXES

Group

Group path, e.g. my-group

All projects in the group, including its subgroups.

Repository

namespace/project

One specific GitLab project only.

Step 1: Create a GitLab Personal Access Token

  1. In GitLab, go to User Settings > Access Tokens (or your Group/Project's Access Tokens page).

  2. Create a new token and grant the scopes below, based on what you need:

YOU WANT

FINE-GRAINED PAT SCOPES

CLASSIC PAT SCOPE

Read-only (index branches and merge requests)

Project: Read, Repository: Read, Branch: Read, Merge Request: Read (add Group: Read for a Group integration)

read_api

Also create branches/merge requests from Jira

above, plus Branch: Create, Merge Request: Create

api

Also register a webhook (see below)

above, plus Webhook: Read, Webhook: Create, Webhook: Delete

api (labelled for branches, merge requests & webhooks)

You don't need to work these out yourself - the Add integration form in Jigit shows the exact scopes required, based on the integration type and options you select.

  1. Copy the token.

Step 2: Add the integration in Jigit

  1. Navigate to Jira Administration > Apps > Jigit > Integrations.

  2. Click Add integration.

  3. Set the Git system to GitLab.

  4. Choose the Integration type: Group or Repository.

  5. Enter the Base URL - this must be https://gitlab.com.

  6. Enter the Path - the group path, or the namespace/project path for a single project.

  7. Paste the Personal access token.

  8. Click Test connection.

  9. Click Create.

image-20260917-025656.png
image-20260917-025737.png

Once connected, an enterprise or self-managed host works exactly like a cloud one - the same branches, pull requests, pipeline status, approvers and commit counts in the issue panel, and the same ability to create a branch, create a pull request, or manually link one from Jira.


Configuring webhooks

By default, Jigit indexes branches and pull/merge requests on a 20-minute poll. Enabling webhooks lets updates flow in as they happen instead of waiting for the next poll - the poll keeps running in the background as a safety net, so nothing is missed if a webhook delivery fails.

Step 1: Turn on webhooks globally

  1. Navigate to Jira Administration > Apps > Jigit > Settings.

  2. Under Git webhooks, turn on Support Git webhooks.

  3. Enter a Webhook Secret - this is required once the toggle is on, and is used to verify incoming webhooks (an HMAC signature for GitHub, a token header for GitLab).

image-20260917-031857.png

The Webhook URL field shown here is for reference. You don't need to copy it into GitHub or GitLab yourself - Jigit registers the webhook with your provider automatically (see Step 2).

Step 2: Turn on webhooks for an integration

  1. Open an existing GitHub or GitLab integration, or create a new one.

  2. Turn on Integrate a webhook. This option is available for both GitHub and GitLab integrations, and only appears once webhooks are enabled globally.

  3. Make sure the integration's token has the extra scope needed to register a webhook (see the table below) - Jigit registers the webhook with your provider's API automatically, so no manual setup is needed on the GitHub or GitLab side.

  4. Click Test connection, then Save.

image-20260917-031149.png

PROVIDER

AUTH TYPE

EXTRA SCOPE NEEDED FOR WEBHOOKS

GitHub

Classic PAT

admin:org_hook / admin:repo_hook

GitHub

Fine-grained PAT

Organization/Repository webhooks: Read and write

GitHub

GitHub App

Webhooks: Read and write (App permission)

GitLab

Fine-grained PAT

Webhook: Read, Webhook: Create, Webhook: Delete

GitLab

Classic PAT

api

Removing a webhook. Turning off Integrate a webhook removes the registered webhook, unless another integration still points at the same GitHub repository or GitLab project.

If registration fails, a banner on save and a tooltip on the integration's status badge show the error returned by GitHub or GitLab directly - for example, a permission or authentication problem. Check the message shown and confirm the token has the scope listed above.


Outbound access for enterprise and self-managed hosts

GitHub.com and GitLab.com need no extra setup. Any other host - GitHub Enterprise Cloud, GitHub Enterprise Server, or self-managed GitLab - needs a Jira admin to approve outbound access from Jigit to that server before the connection will work.

  1. When you enter a Base URL outside github.com / gitlab.com , the modal shows an Admin approval required banner: "Jigit needs outbound access to [host] to reach this server. An admin must approve it before the connection works."

  2. Click Approve on the banner, or simply save the integration - approval is requested automatically either way.

  3. Once approved, the banner changes to confirm outbound access is in place, and Test connection will succeed if everything else is correct.

Only a Jira admin can approve outbound access. If you're setting this up as a non-admin, save the integration anyway - it will show Approval needed in the integrations list until an admin approves it, after which Jigit starts connecting on its own.

This isn't available on Atlassian Government Cloud instances - enterprise and self-managed hosts can't be connected there.

Network and certificate requirements

Keep these in mind for an enterprise or self-managed server:

  • The server must be reachable from the public internet, or you'll need to allowlist Atlassian's egress IP ranges. A server only reachable over a VPN or internal DNS won't work.

  • The server's certificate must be issued by a publicly trusted certificate authority. Self-signed certificates and private/internal CAs aren't supported - there's no Cloud equivalent of a "skip SSL verification" setting.

If Jigit can't reach the server at all, Test connection reports it can't connect and to check the host is reachable with a trusted certificate - this single message covers a DNS problem, a routing problem, or a certificate problem, since Jigit can't tell which one it is from the outside.


Integration statuses

STATUS

MEANING

ACTION

Active

Integration is running normally. Indexing runs every 5 minutes.

None required.

Approval needed

The integration is otherwise fine, but outbound access to its host hasn't been approved yet by a Jira admin. Only applies to GitHub Enterprise, GitHub Enterprise Server and self-managed GitLab hosts - see "Outbound access for enterprise and self-managed hosts" above.

A Jira admin approves it from the banner on the integration, or simply re-saves the integration - approval is requested automatically either way.

Disabled

Integration has been manually disabled.

Toggle the enabled switch to reactivate.

Rate limited

API rate limit was exceeded. Jigit resumes automatically when the limit resets.

Wait for the reset, or (GitHub) switch to a GitHub App for higher rate limits.

Failed

An error occurred (invalid credentials, repository not found, etc.).

Update credentials or the path, then save. Jigit retries on the next scheduler run.

Deleting

The integration and everything it indexed - pull requests, branches, repository selections - are being permanently removed, after choosing Delete. Runs in the background and can't be undone.

None - wait for it to finish. The integration disappears from the list once complete.

Resetting

The integration's indexed data is being cleared, after choosing Delete existing data. The integration itself stays and starts re-indexing from scratch. Runs in the background and can't be undone.

None - wait for it to finish; the integration returns to Active on its own once re-indexing resumes.

Unsupported

One of: an invalid address (not https, or a GitHub address with a path); GitLab 8 or earlier (API v3 only, no Cloud equivalent); an Azure DevOps integration (no Cloud equivalent); or an integration migrated from Data Center whose address needs fixing.

For Azure DevOps or GitLab 8 and earlier, no Cloud equivalent exists - use Azure DevOps for Jira for the former. For an invalid or Data-Center-migrated address, open the integration, correct the Base URL, and save to reactivate it.

The Base URL of a saved integration can't be changed afterwards - its indexed repositories and webhooks belong to that address. To point at a different server, create a new integration. The one exception is an Unsupported integration from a Data Center migration, whose address can still be corrected before it's reactivated.


Delete Existing Data from Integration

This action removes all indexed pull requests, branches, and selected repositories associated with the integration. The integration configuration itself is retained.

The deletion is performed as a background process and may take some time to complete, depending on the amount of indexed data.

This action cannot be undone. Once deleted, the indexed data must be re-synchronized if it is needed again.

Viewing Git data in Jira

  1. Open a Jira issue.

  2. Find the Jigit Development panel in the right-hand sidebar.

  3. The panel lists linked pull requests and branches, including their title, state, and repository name.


Settings

Global settings apply across all Gerrit configurations and GitHub/GitLab integrations.

SETTING

DESCRIPTION

Included Jira spaces

Global include list. If set, Jigit is only active for these Jira project keys. Takes precedence over per-integration include settings.

Ignored Jira spaces

Global ignore list. Jigit does not display data for these spaces, however indexation still occurs.

Branch naming patterns

Patterns for generating branch names from Jira issues. Placeholders: {issue-key}, {issue-type}, {issue-summary}. Default: {issue-type}/{issue-key}_{issue-summary}.

Link branch action

When enabled, a Link branch action appears on Jira issues.

Link change request action

When enabled, a Link change request action appears on Jira issues for creating or linking a Gerrit change.

User authentication strategy

Controls whether users must connect a personal GitHub account. No (default), Required, or Required for action.

Allowed Git systems

Restricts which Git provider types can be added as integrations. Defaults to GitHub only.

Support Git webhooks

Enables near-real-time updates via GitHub and GitLab webhooks, alongside the existing 5-minute poll. Requires a Webhook Secret once turned on. See Configuring webhooks above.

Migration secret

Passphrase used to encrypt credentials in a Data Center export.


User Git Connections

Individual Jira users can connect their own GitHub accounts to Jigit. Data is then displayed based on the user permissions, rather than the integration authentication. This is only mandatory when the User authentication strategy in Settings is set to Required or Required for action.

Users access this page via Profile menu > Jigit Git Connections, or from Apps > Jigit Git Connections in the Jira sidebar.

Method

Description

OAuth

Coming soon.

Personal Access Token

Paste a GitHub PAT generated from your GitHub account settings. The token is stored securely.

Personal user credentials are not migrated from Data Center. After a migration, users must reconnect their accounts via this page.



Updated: November, 2026