Continuous Data Syncs
This feature is in private beta. Request access on the community.

In this guide, we will sync issues from Github as tickets. It entails:

  1. Adding a folder in your repo where your Integration code will live
  2. Defining a ticket data model & configuring the sync
  3. Writing minimal code to fetch issues and transform them into tickets

1. Create your integrations folder

Regardless of your programming language, in your repo, run:

npx nango init && cd nango-integrations # Your new integrations folder

2. Configure your Integration

Open the nango.yaml config file and define a new github-tickets sync and ticket model:

		provider: github
		runs: 'every hour'
			- ticket
		id: uuid
		author: string
		author_id: uuid

Then run:

npx nango g # Generates the model & scaffolding

3. Write your Integration code

Open the github-tickets.ts which contains the following template:

import { NangoSync, NangoHelper } from '@nangohq/node';
import { ticket } from '@nangohq/models';

class GitHubTicketSync extends NangoSync {

async function fetchData(nango: NangoHelper): { []: [ticket.type] } {
	// Integration code goes here.

export GitHubSync;

Fill in the fetchData method with your integration code:

// API requests: handles auth, retries, rate-limiting, pagination and more.
const ghIssues = nango.get('/v1/issues', paginated=true);

// Mapping Github issues to tickets.
const tickets = => { issue.unique_id, issue.username,
    ticket.field.author_id: issue.username_id,

// Return strongly-typed objects.
return { []: tickets }

Finally, deploy your code to Nango:

npx nango deploy

Thatโ€™s it! When a user authorizes Github with Nango Auth, their issues will sync continuously! Nango provides:

  • An SDK & API to access objects (strongly-typed)
  • A webhook to get real-time updates (strongly-typed)
  • A cache with fresh & highly-available data
  • Built-in tooling for easy API requests (pagination, retries, rate-limit handling, transient errors etc.)
  • Monitoring & Management console
  • Automatic scaling & reliability