How to Set up a ServiceNow GitHub Integration: The Comprehensive 2023 Guide

ServiceNow GitHub integration

If you use platforms like ServiceNow and GitHub to organize your teams, you may want to consider a ServiceNow GitHub integration at some point along the way. Connecting these two platforms will simply mean easier and more accurate data sharing, as with integrations you can do that automatically and save everyone a lot of work.

Automatically filtering and sorting the many issues and tickets you use sounds like a difficult challenge. The right integration solution though can make it much easier. So in a few simple steps, you’ll see how to set up a ServiceNow GitHub integration with the least fuss possible.

So let’s get right into it!

Here’s what we’re going to cover in this blog post:

Why Integrate ServiceNow and GitHub

ServiceNow is a workflow platform able to handle everything from service management to help desk support. It offers a wide selection of web-based tools and several extensions.

With a business model focused on large teams and organizations, it is good for keeping track of large amounts of information and handling complex business relationships.

On the other hand, GitHub is a code storage platform that enables developers to easily handle version control and code distribution. It allows you to create and discuss issues, making it easier to manage projects.

GitHub supports open-source projects and is a great way to build a community of coders working together to help improve products.

These platforms contain huge amounts of information and allow teams to work together efficiently. So integrating them properly can help teams share data and manage workflows collectively while keeping the benefits of the individual platforms without jeopardizing either side’s autonomy or security. 

Choosing the Right Technology For a ServiceNow GitHub Integration

Your teams need a solution that is reliable enough to handle outages and errors, flexible enough to adapt to their changing needs, and allows them to choose how they want to share information with the other side. 

The right solution should also guarantee your team’s integration is decentralized i.e each side has independent control over what data needs to be shared and with whom, so they can keep working in the comfort of their own environment. 

The tool we’ve chosen for this guide is Exalate because it meets the above criteria above. Let’s see how to use it in practice.

How to Set up a ServiceNow GitHub Integration in Six Steps 

Step 1 – Install Exalate on ServiceNow

First of all, you need to install Exalate. You can do this on your ServiceNow instance with Docker, or you can ask Exalate to set up a separate node for you. I’ll use the second option in this tutorial.

To learn more about both options, take a look at this documentation.

To get a node, go to Exalate’s integrations page, and click ServiceNow.

Exalate node for ServiceNow

A form will appear. Fill this in to request an evaluation instance. Enter your details and click “Submit”.

You’ll get a message that your node is ready. You also need to create a ServiceNow account with the appropriate permissions.

Once you’ve created the right user accounts, go to your Exalate node and click “general settings”. Put in the URL of your ServiceNow instance, along with the username and password of your proxy user.

Now you should be able to access the Exalate console. You’ll need to use an account with administrator permissions to do so.

Exalate for ServiceNow trial

Step 2 – Install Exalate on GitHub

Next, you need to set Exalate up on GitHub. To do that, log in to your account, then click “Marketplace” on the top menu. Type “Exalate” into the search bar and press return. You’ll see “Exalate Issue Sync” appear. 

exalate for GitHub

Note: Exalate is also available for GitHub Enterprise. For installing Exalate on GitHub Enterprise Cloud, check this article.

Click on the app listing, then on “Set up a plan”, followed by “Install it for free”. Click the green button to complete your order and begin the installation.

Note: Exalate offers a free trial, but it is not a free app. 

install exalate on github

Exalate needs access to your projects and you can choose whether to give it access to specific repositories, or to all of them. It can read the metadata and needs both read and write access to issues and pull requests. If you are happy with that, click the green “Install” button.

Now Exalate will automatically create a node for you. Th system will redirect you to it, and you will have to enter your details. After that, click the “Agree and submit” button.

verify exalate instance for ServiceNow GitHub integration

You’ll get a confirmation email in your intray. Click the button in the email to verify your account. Then, click continue.

exalate for github access token

Next, you need to create an access token for use in Exalate. To do that, go back to GitHub. Open the top-right menu and click “settings”. On the next screen, look at the menu on the left and click “Developer settings”. Then on the next screen, click “Personal access tokens”.

personal access token for ServiceNow GitHub integration

Click the “Generate new token” button toward the top right. A detailed set of options will appear. You can optionally add a note to help remind you what your token is for later. 

create an exalate access token

The only option you need to select is “repo”, which should also automatically select all the other tick boxes in its group. After that, click the green button at the bottom to generate the token. Be careful on the next screen, because it’s the only chance you get to actually copy the token. If you forget, you’ll have to do it all over again!

Highlight the token (the long number with the light green background), and copy it somewhere safe. You have to use it each time you log in, it isn’t just a one-off activation, so don’t delete it after logging in for the first time. 

Next, go back to the Exalate node page and paste it into the “Token” box. Click the login button and, if all goes well, the system should take you to the main Exalate menu.

Exalate for GitHub trial

All right! You now have Exalate on both sides, so let’s set up the connection.

Step 3 – Connect Your ServiceNow and GitHub Instances

Now that you have Exalate running on both platforms, you can go ahead and connect them to one another. You do this by initiating the connection from one side and accepting it on the other side.

It doesn’t matter whether you initiate the connection in ServiceNow or GitHub. For this guide, I’ll use GitHub to initiate the connection, then accept it in ServiceNow. Exalate uses a common interface across platforms, so the process is much the same either way.

initiate servicenow GitHub integration

In your GitHub node, go to the Exalate menu and click “Connections” if you aren’t there already. This will show you any existing connections, but since this is the first time you’re here, there won’t be any. 

Click “Initiate connection”.

Initiate connection between Github and ServiceNow

Next, enter the destination URL i.e the ServiceNow URL. After checking if Exalate is on the destination side, you will need to choose the configuration type. Exalate comes in 2 configuration modes: the Basic mode and the Script mode.

The Basic mode already has GitHub and ServiceNow entities mapped with each other. Synchronization between them happens according to the mappings. So if you have simple synchronization needs then you can go ahead and use this mode.

Exalate also supports a Free Plan that comes with the Basic mode and it has up to 1000 free syncs per month.

The Script mode, on the other hand, has advanced configurations. With this mode, you can control what information to send or receive with the help of sync rules. It works best for complex and advanced integration use cases.

Let us see how they both work.

The Basic mode

To continue using the Basic mode, click “Basic” on the screen shown above and then hit “Next”.

Select repository in Github for syncing

Proceed to select the repository on the GitHub side. This will be the repository in which Incidents from ServiceNow will be synced. Select the one you want from the drop-down list and click “Next”.

Note: By default, the Basic Mode supports syncing the summary, description, comments, attachments, and issue types.

Service now connects with Github

You then need to verify if you have admin access to the destination instance, i.e. ServiceNow in our case. Proceed with the verification by clicking “Yes, I have admin access”. Then click “Initiate”.

In case you don’t have access, you will be required to copy an invitation code on the GitHub side and manually paste it on the ServiceNow side. We will see how to do this in detail in the Script mode.

Incident from ServiceNow to sync

After verification, you will be redirected to the ServiceNow instance. Here, you need to enter the incident number you want to synchronize on the GitHub side. If you click “Exalate” a new issue will be created in GitHub. Information between the incident and the issue will be synced bi-directionally thereon. A similar screen on the GitHub side will require you to give an issue key. A reverse procedure will be followed then.

incident synchronized between Github and ServiceNow

Issues and incidents can be synchronized, as explained in this section. In addition to this, you can create automatic synchronization triggers for syncing issues and incidents, or you can sync existing entities using the “Bulk Connect” option.

The Script mode

To continue with this mode, click “Next” when you select “Script”.

Initiate connection from Github to ServiceNow

You then need to enter a name for your local instance (GitHub in this case), and the destination instance (ServiceNow). The names you use will be combined to make a connection name. You can change this if you like.

There’s also an optional field for a description. This is especially useful if you have multiple connections. 

When you’re ready, click “Next”.

Select repository for syncing issues in Github

On the next screen, you need to pick a GitHub repository from those available. Items in this repository will be synchronized with those in ServiceNow. Make a choice, and click “Initiate”.

Invitation code to sync Github and ServiceNow

Exalate will now generate a code that needs to be pasted into ServiceNow to complete the connection. Click the “Copy invitation code” button, and paste the code somewhere safe, like a text editor. 

Then open ServiceNow. You can do this by clicking “Go to remote”, or you can navigate there directly. If you’re using your own instance, you can find the Exalate console by typing “Exalate” into the search field above the left-hand menu.

Accept invitation on the ServiceNow instance

In the Exalate console, click “Connections”. Then click the “Accept invitation” button.

Paste the invitation code in ServiceNow

You’ll see a large text field. Paste the invitation code you got from GitHub here and click “Next”. Click through the next confirmation screen and the connection will be established.

Configure sync for Github ServiceNow integration

Now you’ve set up your connection. If you click the “Configure Sync” button, the system will take you straight to the “Edit connection” screen.

In the next steps, you can configure the connection to do exactly what you want.

Step 4 – Configure Your Connection to Determine What Information Gets Shared

In this step, you can tune the connection to share the precise data you need. As well as specifying which items to synchronize, you can choose which necessary fields and how they map to each other. You can also use your own values for specific fields.

To edit a connection, find its listing in the connections screen. You’ll see four icons on the right. Click the furthest left to edit your connection.

You’ll now see a screen with four tabbed areas. These are “Rules”, “Triggers”, “Statistics” and “Info”. You’ll look at triggers in step five. For now, make sure you select “Rules” and have a look at the boxes below.

Github ServiceNow sync rules

There are two large areas containing outgoing sync rules and incoming sync rules. These define how synchronized items map onto one another. Above those is a selection allowing you to change the repository the rules apply to.

Take a closer look at the outgoing sync section. The rules here copy items from the issue to the replica that will go over to the other side. If you don’t want all the information sent over, you can comment or delete any line you like. 

Commenting by adding two slashes (//) at the start of the line is also a good way to quickly enable and disable items. That’s useful if you want to restrict the information you send out, then add it back later.

By default, the mappings use the same suffix for every item, so replica.assignee is mapped to issue.assignee. You could make the GitHub assignee map to a label in ServiceNow by removing the assignee line and changing the label line to read: replica.label = issue.assignee.

Also, you can use specific values. For example, changing that line to replica.label = “from GitHub” would add that label to synced ServiceNow items. That way, your team can see which items came from the synchronization.

When you’ve got everything set up how you want, click “Publish” at the top right to save your changes. Don’t forget to check with both of your teams to make sure items are being exchanged correctly. It is easy to make a mistake, but also easy to fix it.

There’s much more you can do with sync rules. Read this documentation to find out.

Step 5 – Set Up Automated Synchronization Triggers

Synchronization triggers define the conditions for information exchange and also control the syncs. 

There are two places to edit them. From the edit connection screen used in the previous step you can click “Triggers”. That’s what I’ll do here. You can also access a separate triggers screen from the left-hand menu. It works almost the same way, except the triggers listed there have a separate field to show what connection they apply to.

SNOW GitHub sync triggers

The triggers screen shows your existing triggers but is blank the first time you look at them. To start, click the “Create trigger” button on the right.

add trigger to your sync

There are several controls on the add trigger screen. At the top is a dropdown box to pick what type of entity the trigger applies to. 

Next, in the “If” section, you write a query that picks out the issues you want to synchronize. You can read more about the query syntax here.

There’s a space to leave notes. As with the connection screen, this can be a lifesaver if you have lots of triggers, or multiple team members trying to figure out what each other is doing.

Last but not least is the “Active?” switch. Don’t forget to turn this on, or nothing will happen. You can also use it to disable your triggers temporarily.

When you’ve finished, click the “Add” button.

Step 6 – Start Synchronizing Tasks

Now that you’ve set everything up, all you have to do is wait for Exalate to synchronize your items. If it isn’t done straight away, don’t panic! For performance reasons, Exalate doesn’t check continually, but if you go away and make a coffee, it should be done when you get back. 

The good thing about Exalate is that you can now leave it to work automatically without having to do any more work. Having seen the benefits though, you may want to make adjustments or even set up a sync with another platform.

Common Use Cases 

There are many scenarios where you might want to integrate ServiceNow and GitHub. Here are some examples.

Developers and Support Team

A common use for integration is to connect your support team and your developers. The support team deals with large numbers of issues from customers. These issues may be duplicated and contain details of customer interaction, along with the technical information the developers are interested in.

The right ServiceNow GitHub integration can automatically filter issues from the support team and copy them into the developers’ issue tracking system on GitHub. When the developers resolve the issue, the integration passes the updates back to ServiceNow, alerting the support team to inform the customer that the issue has been resolved.

Product Development and Quality Control

A product development team might use issues in GitHub to direct engineers in building the product they want. The quality control system analyzes requirements and works with the product development team to convert those requirements into feature requests that the engineers implement.

If the quality control team is tracking their work in ServiceNow, they can benefit hugely by directly monitoring how the issues they raise are implemented in GitHub. Synchronizing systems allow them to see information that is relevant to them, and provide further feedback if needed.


Integrating software platforms is easy with the right solution. In just a few steps, you can get your teams (and even companies) to share information and work together seamlessly. Once the integration is ready, it can exchange items between your teams without creating extra work for anyone.

Making changes and evolving your integration is just as easy to do, so you control when and how data is shared without worrying that everything will come crashing down.

With a flexible ServiceNow GitHub integration, your teams can focus on their own tasks in their own familiar environment while enjoying easy and secure collaboration.

Frequently Asked Questions

Can GitHub integrate with ServiceNow?

Zendesk can integrate with ServiceNow using native solutions like IntegrationHub as well as third-party integration tools like Exalate, which are available in the marketplace of both platforms. Dev teams using GitHub can connect with customer support agents working with ServiceNow.

How do I connect GitHub with ServiceNow?

To connect GitHub with ServiceNow, you’ll need to find a third-party integration solution from the marketplace. This solution (Exalate, Skyvia, etc.) fetches data from one platform’s API and sends it across to the other. 

Can I use a no-code tool to integrate GitHub with ServiceNow?

Yes, you can use no-code tools to integrate GitHub with ServiceNow. No-code integration solutions provide you with pre-built connectors, eliminating the need to write lines of code for mapping syncs. Some no-code integration tools include Zapier, Exalate (Basic Mode), and SnapLogic.

Recommended Reads:

Comments are closed.