Nango is a product integration platform for developers. It helps you build, manage, and scale integrations with third-party APIs, through a single interface.

New to Nango? Start with:

Demo video

What is Nango?

Quickstart

All Integrations

Join our Slack

Talk to an expert

​
Demo video

​
What is Nango?

Nango is the most comprehensive product integrations platform designed for developers at B2B SaaS companies.

Nango helps you build, manage, and scale integrations with third-party APIs, through a single interface. It is as flexible as building integrations in-house, while taking care of API-specific complexities for you, so you can focus on making integrations your best product feature.

With Nango you get:

  • Hundreds of pre-built integrations
  • Developer tooling pre-configured for each API
  • Comprehensive API documentation
  • Access to API experts

​
How is Nango different from unified APIs and embedded iPaaS?

Nango is built to replace building integrations in-house—offering the same flexibility and control, but faster and with less maintenance overhead. It is strictly developer-first, designed to support any API and empower developers to create exactly the integrations their customers need.

Unified APIs and embedded iPaaS tools take a more rigid approach, focusing on pre-built use cases that limit what you can build. Embedded iPaaS lack key abstractions developers rely on, like end-to-end type safety and API unification. Unified APIs, meanwhile, are locked into predefined schemas and use cases, making them a point solution at best.

Nango is built with a different mindset: to unleash integration creativity. By providing best-in-class developer tooling tailored to each API, Nango removes limitations and empowers developers to create integrations that stand out—whether through deep customization, polished experiences, or handling the unique quirks of external APIs.

For a full comparison, read How is Nango different from embedded iPaaS and Unified APIs?

​
3 steps to integrate Nango

The steps to integrate Nango.

1

Get user permission in your app

Use the Nango frontend SDK to get the user’s permission to access their external data.

Nango guides the user through the auth flow in a popup window.

Store the connectionId in your database to retrieve the user’s data later.

Frontend: Trigger the OAuth flow.
const nango = new Nango({ connectSessionToken });

// Shows authorization popup to the user.
await nango.openConnectUI({
    onEvent: (event) {
        if (event.type === 'connect') {
            // The auth flow succeeded. The user is connected!
            saveToDatabase(event.payload.connectionId, event.payload.providerConfigKey);
        }
    }
});

When a new user connects your integration, Nango automatically starts fetching their data (e.g. issues, contacts, files, etc.) in the background.

2

Receive updates & fetch the new data

Nango uses webhooks to notify your backend when external user data has been added, updated or deleted. Nango will only notify you when there are actual changes.

Backend: Webhook payload with new data
{
    "connectionId": "user123",
    "providerConfigKey": "zendesk",
    "model": "ticket",
    "responseResults": { "added": 2, "updated": 6, "deleted": 0 },
    "modifiedAfter": "2023-05-31T11:46:13.390Z"
}

When you receive a Nango webhook, fetch the most recent data from Nango using the backend SDK or API.

Nango returns the data in the schema of your choice, which can be standardized across different APIs.

You can directly save this data to your database, or process it further, as needed.

Backend: Fetch & save new records.
const records = await nango.listRecords<Ticket>({
    providerConfigKey: 'zendesk',
    connectionId: 'user123',
    model: 'ticket',
    modifiedAfter: modifiedAfter
});

saveToDatabase(records);
3

Write back to external APIs

Push updates back to external APIs with standardized schemas across different APIs.

Backend: Write back to external APIs.
const result = await nango.triggerAction({
    providerConfigKey: 'zendesk',
    connectionId: 'user123',
    action: 'create-ticket',
    input: { "title": "...", "content": "..." }
});
4

Optional: Customize integrations

Nango stands out in its ability to let you create custom integrations through code.

Support intricate workflows with composed API calls, custom schemas & complex transformations.

Your custom integration code is deployed and run by Nango, similarly to lambda functions.

Questions, problems, feedback? Please reach out in the Slack community.