How to Export GitHub Issues and Pull Requests to Google Sheets Automatically

Do you find it intimidating to search your dev team’s GitHub repo looking for project details to share in a spreadsheet? You’re not alone. Any project manager or product team can tell you how important it is to provide stakeholders with timely and accurate reports on development projects. But you need to know the in’s and out’s of GitHub to find what you’re looking for. And even then, it can take hours relaying the details of GitHub issues or pull requests into a spreadsheet, such as Google Sheets or Microsoft Excel. One solution that can make that process far easier for whoever’s building the report is a 2-way sync with Unito. This guide will show you exactly how to set up a simple integration between GitHub and Google Sheets to send issues and pull requests into a table so that no one needs to do so manually.

By the end of this walkthrough, you’ll know how to:

  • Populate Google Sheets rows with GitHub issues or pull requests;
  • Keep your spreadsheet up-to-date in real-time with a 2-way sync.

Here’s what a fully-integrated GitHub-Google Sheets workflow looks like after syncing with Unito:

Google Sheets after syncing with Unito. Synced fields include issue, issue type, milestone, assignee, issue number, status, due date and title.
This integration can’t create pull requests and doesn’t support syncing comments or descriptions to Google Sheets. But you can sync issues from your pull requests into your spreadsheet!

New to Unito? Check out our GitHub + Google Sheets integration overview.

Why connect GitHub to Google Sheets with Unito?

This process requires a very precise technical skillset, in particular how to find issues, pull requests, and milestones in GitHub and relay key information easily into a spreadsheet. Setting up an integration with Unito means no one has to worry about where and how to find those issues or pull requests anymore. You simply set it and forget it, then as you create work items (e.g., GitHub issues) or sync historical work items, they will appear automatically in your spreadsheet.

Save time with Unito’s 2-way integration and focus team efforts elsewhere

Think of Unito as your personal assistant when it comes to building reports. That means you can spend more time and effort on your dashboard or managing other projects. The basics of data entry are fully automated from GitHub to Google Sheets once you have the right integration in place. You’ll be able to sync any GitHub issues (including those from pull requests) into a spreadsheet in order to review your development team’s progress from the simplicity and flexibility of a spreadsheet. The only caveat is that you can’t create pull requests from Google Sheets back to GitHub.


Feel free to skip ahead if you’ve already started building your GitHub – Google Sheets flow.

Before we sync GitHub and Google Sheets with Unito:

  • Set up your Google Sheet before launching Unito. This means creating a table header in the first row with the names of every GitHub field you wish to sync. You can find a full list of supported GitHub fields here.
  • Once you’ve added a table header to your spreadsheet, you need to install the Unito add-on for Google Sheets in order for your data to sync from GitHub.
  • Add Unito to GitHub through the GitHub Marketplace if you haven’t already. This article can show you how if you need help.

Why do I need a table header in Google Sheets?

Unito needs to know where to put the details of your GitHub issues and pull requests. The table header serves this purpose with each column acting as a separate container for each field. But since you can name your cells whatever you’d like, it’s a good idea to name each column after the matching fields in GitHub so it’s easier to look through your data later. Here’s an example of our completed table header. Every cell in the first row is similar if not identical to fields in GitHub so that anyone who looks at our spreadsheet can identify them easily:

The first and last columns are created by the Unito add-on and must exist in your sheet in order for data to sync properly. But you can hide the columns if you don’t want to see them in your reports.

Step 1. Connect GitHub and Google Sheets with Unito

  1. Login the Unito App and click + Create Flow.
  2. Now, click Start Here to connect your tools. Follow the on-screen instructions to authorize GitHub and Google Sheets . If you need help with, here’s a breakdown of every permission needed by Unito.
  3. Next, select +Add a tool to this flow in either column. Then, +Choose account to specify the GitHub repository and Google Sheet you plan on syncing. If you can’t find your sheet, you can copy paste the URL into the search bar.
  4. Click Confirm.
Connect GitHub and Google Sheets to Unito
You can either search for the name of the Sheet or enter the matching URL directly into the search bar.

Step 2. Set a One-Way Flow between GitHub and Google Sheets

This step tells Unito where and how to create new work items (e.g., Google Sheets rows or GitHub issues). Since we’re setting up a reporting use case, you can select a one-way sync at this stage. Later, we’ll choose a two-way sync for field mappings so that any changes we make in GitHub will still appear in Google Sheets so that our integration keeps our tools updated in real-time as the development team works.

Set a One-Way Flow between GitHub and Google Sheets

What are work items?

Step 3. Set up rules to filter data between GitHub and Google Sheets

After setting a flow direction, you can now choose rules to filter specific GitHub issues or pull requests. You can do this by selecting a trigger that Unito will identify in your tools so that only work items matching that description sync with Google Sheets. You could filter by assignee, issue type, labels you’ve created, etc. This part is entirely up to you, but in our demo, we kept things simple, opting to sync by label as you can see below.

Setting rules to filter out certain GitHub issues from syncing to Google Sheets wtih Unito
In this case, only issues with the label “enhancement” will sync to Google Sheets. If we select multiple labels, then any issues with any of the labels we choose will sync to our spreadsheet.

You can also decide if any actions should be automated after the row is added to your Google Sheet. This could include setting a default assignee, changing a specific field, and more.

Step 4. Select Two-Way field mappings between issues and rows

Fields represent the details of your GitHub issues and Google Sheets rows: assignee, issue number, due dates, status, label, etc. Typically we can either auto-map our fields or go with a DIY approach. Since Google Sheets allows us to name our fields whatever we wish, we’ll have to start from scratch for this particular integration.

Select Start mapping manually in this instance.

At the next screen you can click on + Add mapping to pick individual fields in GitHub that will sync over to Google Sheets. Here’s an example of our completed set of field mappings:

Select which fields to keep in sync between GitHub issues and your Google Sheets
In this case, any fields with a two-way sync selected can be updated in either tool, while those with only a one-way sync have a source and destination. If I change text in the destination tool, the source will be unaffected. But If I change text in the source tool, then the destination will also update accordingly.

Exact mappings might vary for your use case, but this is generally what you want. The key information from GitHub issues will appear in Google Sheets and nothing extra. Then your colleagues or stakeholders can quickly review without asking for help.

You can learn more about field mappings here.

Step 5. Save, close, and launch your connected GitHub-Google Sheets workflow!

And that’s it! Just like that, you’ve built a two-way flow to automate issue creation between GitHub projects with Unito!

If you’ve followed the steps above, your flow will now:

  • Send your GitHub issues into Google Sheets based on your rules.
  • Keep those issues synced automatically between GitHub and Google Sheets with live two-way updates.

Once all your fields are mapped, you’re done! You can launch your flow and watch as GitHub issues get synced over to Google Sheets. Build flows for other GitHub repos and you could have a single spreadsheet database to track all the work your development team is doing.

Essential Unito features for this use case

Custom fields

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.

Ready to automate your reports?

Try Unito for 14 days, absolutely free.

Try it free

What’s next after you sync multiple GitHub projects with Unito?