Skip to content

Latest commit

 

History

History
147 lines (116 loc) · 6.31 KB

what-is-nango.mdx

File metadata and controls

147 lines (116 loc) · 6.31 KB
Raw
title sidebarTitle description
What is Nango?
What is Nango?
Nango is the most powerful product integrations platform for developers.
<iframe style={{ position: 'absolute', top: 0, left: 0, width: '100%', height: '100%' }} src="https://www.youtube.com/embed/oTpWlmnv7dM?modestbranding=1&rel=0&autohide=1" title="YouTube video player" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen ></iframe>

Nango Overview

Nango is the most powerful 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 - Ready-to-use integration templates for 250+ APIs

Developer tooling pre-configured for each API - Authorization: OAuth, API key, basic, custom - Rate-limit handling, pagination and retries - Two-way sync infrastructure - End-to-end type safety and runtime data validation - Real-time webhook infrastructure - Observability and alerting: HTTP requests, customer-level reporting, etc - Per-customer integration configuration: field mappings, toggle features, etc - Tooling to develop, test, deploy, and migrate custom integrations (git-based) - API unification with your own schemas - UI components to embed in your app

Comprehensive API documentation - Hundreds of API quirks, gotchas, helpful links, and hard-earned learnings

Access to API experts - Experts for enterprise APIs (Netsuite, Workday, Salesforce, SAP, etc.) - Sandbox accounts - Service to build your custom integrations

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?

Overview of integrating Nango

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.

```ts 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(connectionId, integrationId);
        }
    }
});
```

<Tip>
When a new user connects your integration, Nango automatically starts fetching their data (e.g. issues, contacts, files, etc.) in the background.
</Tip>
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. 
```json 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.

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

saveToDatabase(records);
```
Push updates back to external APIs in a way that is: 
- **Synchronous:** Have your changes immediately reflected.
- **Unified:** Benefit from standardized schemas across different APIs.
- **Customizable:** Support intricate workflows and composed API calls.

```ts Backend: Write back to external APIs.
const result = await nango.triggerAction({
    providerConfigKey: 'zendesk',
    connectionId: 'user123',
    action: 'create-ticket',
    input: { "title": "...", "content": "..." }
});
```
Nango stands out in its ability to let you create custom integrations through code. 
Your custom integration code is deployed and run by Nango, similarly to lambda functions.

<Tip>
**Questions, problems, feedback?** Please reach out in the [Slack community](https://nango.dev/slack).
</Tip>