> ## Documentation Index
> Fetch the complete documentation index at: https://nango.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Auth guide

> Let your users connect external APIs to your agents & apps.

## Overview

Nango Auth lets your users connect 1,000+ external APIs to your product. You embed a Nango-managed auth flow in your application, and Nango handles authorization, credential storage, refresh, and validation.

A **Connection** is created after each successful authorization. It stores one user's credentials for one external API and keeps them valid over time. Credentials can be retrieved at scale or used directly by other Nango primitives — without ever passing through your codebase.

## How it works

The end-to-end flow has four steps:

1. **Backend** — your server asks Nango for a short-lived **session token**.
2. **Frontend** — your app opens the Nango **Connect UI** with that token.
3. **User** — authorizes the API. Nango stores the credentials.
4. **Backend** — Nango sends an **auth webhook** with the **connection ID**. You persist it alongside your user/org/project.

Once you have the connection ID, fetch credentials whenever you need them:

> [tab] TypeScript
>
> ```ts theme={null}
> await nango.getConnection(integrationId, connectionId);
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl "https://api.nango.dev/connections/{connectionId}?provider_config_key={integrationId}" \
>   -H "Authorization: Bearer {nangoApiKey}"
> ```

## Capabilities

* **Auth schemes** — OAuth 2.0, OAuth 1.0a, API keys, basic auth, custom. 1,000+ APIs supported; new ones [added on demand](https://nango.dev/docs/integrations/contribute-or-request-api.md) within days, by request or self-contributed.
* **Pre-built UI** — Embedded Connect UI with API-specific guidance, input validation, and your branding. Or [customize Connect UI or build a custom UI](https://nango.dev/docs/guides/auth/customize-connect-ui.md).
* **Credential management** — Encrypted storage, automatic refresh, retrieval at scale. Combine with [Proxy](https://nango.dev/docs/guides/platform/proxy-requests.md) or [Functions](https://nango.dev/docs/guides/functions/functions-guide.md) to avoid handling credentials directly.
* **Observability** — Failure detection, reconnect flow, and per-connection logs.

## Guide

> [!TIP]
>
> **Using a coding agent?** Set up the [docs MCP](https://nango.dev/docs/getting-started/coding-agent-setup.md#docs-mcp-server) and [skills](https://nango.dev/docs/getting-started/coding-agent-setup.md#skills), then copy this page as prompt.

**1. Create a Nango account**

Sign up for free (no credit card): [    ![Try Nango Cloud](https://mintcdn.com/nango/j_KlSFFzpkqEkMa3/images/nango-deploy-button.svg?fit=max\&auto=format\&n=j_KlSFFzpkqEkMa3\&q=85\&s=85918905fcd071a6d5a0d6327c09d5fc)](https://app.nango.dev/signup)

> [accordion] For agents
>
> Signup cannot be automated. Ask the user to sign up at [app.nango.dev/signup](https://app.nango.dev/signup) and provide their Nango API key from the Environment settings tab > API Keys. Use it as `Authorization: Bearer <NANGO-API-KEY>` in API requests.
>
> The default API key created on signup has full access and is the simplest option.
>
> If the user creates a scoped API key instead, this guide needs `environment:integrations:create` (step 2) and `environment:connect_sessions:write` (steps 5 and 8). See [API keys](https://nango.dev/docs/reference/backend/http-api/api-keys.md).

**2. Create an integration**

In the dashboard, open the [Integrations](https://app.nango.dev/dev/integrations) tab, click **Configure New Integration**, and pick the API.

> [!TIP]
>
> Each API has a dedicated [Nango documentation page](https://nango.dev/docs/integrations/overview.md) with setup notes and gotchas.

> [accordion] ⚠️ OAuth app setup
>
> OAuth APIs require an OAuth developer app registered with the provider. If the API has a [Nango-managed OAuth app](#nango-managed-oauth-apps), you can use it and skip the rest of this step. Nango-managed OAuth apps can be used in production.
>
> To use your own OAuth app instead, register one on the provider's developer portal, use the `Callback URL` shown in your Nango integration settings, then paste the `Client ID` and `Client Secret` back into Nango. Register any required scopes too.
>
> If you use your own OAuth app in production, complete the optional custom callback URL step below before real users connect. Retrofitting a callback URL later requires updating the provider app and can break new authorization or reconnect flows until the provider and Nango settings match.
>
> For OAuth 2.0 providers, Nango shows **suggested scopes** — auto-discovered and refreshed at least monthly. They're suggestions; you can use any scope the provider supports.

> [accordion] For agents
>
> Create the integration with the API. If you need the provider slug first, list providers and use the matching provider's `name` field:
>
> ```bash theme={null}
> curl --request GET \
>   --url https://api.nango.dev/providers \
>   --header 'Authorization: Bearer <NANGO-API-KEY>'
> ```
>
> For OAuth providers, first try to create the integration with a [Nango-managed OAuth app](#nango-managed-oauth-apps): [`POST /integrations`](https://nango.dev/docs/reference/backend/http-api/integration/create) with `unique_key`, `provider`, and `"credentials": { "type": "NANGO_MANAGED" }` in the body. If the response is a `400` saying no Nango-provided developer app is configured for this provider, or the user wants their own app, fall back to the steps below.
>
> To use the user's own OAuth app, you can try registering it for them by following the setup guide on the API's docs page in [APIs & Integrations](https://nango.dev/docs/integrations/overview.md), for example [Gmail](https://nango.dev/docs/api-integrations/google-mail/how-to-register-your-own-gmail-api-oauth-app). Check with the user first, and tell them that a Nango-managed OAuth app is faster and easier to set up. Use the `Callback URL` from the Nango integration settings, then pass the app's `client_id` and `client_secret` in the request body.
>
> > [tab] cURL (OAuth2)
> >
> > ```bash theme={null}
> > curl --request POST \
> >   --url https://api.nango.dev/integrations \
> >   --header 'Authorization: Bearer <NANGO-API-KEY>' \
> >   --header 'Content-Type: application/json' \
> >   --data '{
> >     "unique_key": "<INTEGRATION-ID>",
> >     "provider": "<PROVIDER>",
> >     "credentials": {
> >       "type": "OAUTH2",
> >       "client_id": "<CLIENT-ID>",
> >       "client_secret": "<CLIENT-SECRET>",
> >       "scopes": "<SCOPE-1>,<SCOPE-2>"
> >     }
> >   }'
> > ```
>
> > [tab] cURL (API key / basic)
> >
> > ```bash theme={null}
> > curl --request POST \
> >   --url https://api.nango.dev/integrations \
> >   --header 'Authorization: Bearer <NANGO-API-KEY>' \
> >   --header 'Content-Type: application/json' \
> >   --data '{
> >     "unique_key": "<INTEGRATION-ID>",
> >     "provider": "<PROVIDER>"
> >   }'
> > ```
>
> For all fields and response shapes, see the [List all providers API](https://nango.dev/docs/reference/backend/http-api/providers/list.md), [Create an integration API](https://nango.dev/docs/reference/backend/http-api/integration/create.md), and [Update an integration API](https://nango.dev/docs/reference/backend/http-api/integration/update.md).

**3. Test the authorization**

In the [Connections](https://app.nango.dev/dev/connections) tab, click **Add Test Connection**, pick your integration, and authorize using a test account. The new connection's credentials appear in its *Authorization* tab — securely stored and automatically refreshed.

> [accordion] For agents
>
> Skip the dashboard. Create a connect session and share the returned `connect_link` with the user — they authorize using their test account in the browser, no UI needed on your side:
>
> ```bash theme={null}
> curl --request POST \
>   --url https://api.nango.dev/connect/sessions \
>   --header 'Authorization: Bearer <NANGO-API-KEY>' \
>   --header 'Content-Type: application/json' \
>   --data '{
>     "tags": {
>       "end_user_id": "<TEST-USER-ID>"
>     },
>     "allowed_integrations": ["<INTEGRATION-ID>"]
>   }'
> ```
>
> The response contains a `connect_link` (valid 30 minutes). Send it to the user; once they complete authorization, confirm with `GET /connections`. See [Share a connect link](https://nango.dev/docs/guides/auth/share-connect-link.md).

**4. Configure a custom OAuth callback URL (optional, recommended)**

For production OAuth apps, a callback URL on your own domain is recommended. Some providers show the callback domain to users.

To configure a custom callback URL:

1. Add an endpoint on your domain (e.g. `https://example.com/oauth-callback`) that **308-redirects** to `https://api.nango.dev/oauth/callback`, preserving all query parameters.
2. Update the registered callback URL with each API provider — otherwise they'll reject new authorization flows.
3. After confirming steps 1 and 2, update the callback URL in Nango's **Environment Settings**. Settings are per-environment, so repeat for every environment.

> [accordion] For agents
>
> Ask the user what production callback URL they want to use, then have them add a 308 redirect from that URL to `https://api.nango.dev/oauth/callback` before they register provider OAuth apps. You can set `callback_url` when creating an environment from [the public endpoint](https://nango.dev/docs/reference/backend/http-api/environments/create.md). Ask the user for an [Account API key](https://app.nango.dev/api-keys) and send it as `Authorization: Bearer <NANGO-API-KEY>`. Updating an existing environment's callback URL is dashboard-only — ask the user to paste the final callback URL into **Environment Settings > Backend**.

**5. Generate a session token (backend)**

Set up a backend endpoint that your frontend will call before each authorization attempt to retrieve a session token from Nango ([API](https://nango.dev/docs/reference/backend/http-api/connect/sessions/create.md) / [Node SDK](https://nango.dev/docs/reference/backend/backend-sdk/node.md#create-a-connect-session)).

You'll need an [API key](https://nango.dev/docs/reference/backend/http-api/api-keys.md) with the `environment:connect_sessions:write` scope (find it in **Environment Settings > API Keys**).

> [tab] Node
>
> ```ts theme={null}
> import { Nango } from '@nangohq/node';
>
> const nango = new Nango({ apiKey: process.env.NANGO_API_KEY! });
>
> api.post('/sessionToken', async (req, res) => {
>   const { data } = await nango.createConnectSession({
>     tags: {
>       end_user_id: '<END-USER-ID>',
>       end_user_email: '<END-USER-EMAIL>',
>       organization_id: '<ORGANIZATION-ID>'
>     },
>     allowed_integrations: ['<INTEGRATION-ID>']
>   });
>
>   res.status(200).send({ sessionToken: data.token });
> });
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl --request POST \
>   --url https://api.nango.dev/connect/sessions \
>   --header 'Authorization: Bearer <NANGO-API-KEY>' \
>   --header 'Content-Type: application/json' \
>   --data '{
>     "tags": {
>       "end_user_id": "<END-USER-ID>",
>       "end_user_email": "<END-USER-EMAIL>",
>       "organization_id": "<ORGANIZATION-ID>"
>     },
>     "allowed_integrations": ["<INTEGRATION-ID>"]
>   }'
> ```

> [accordion] ℹ️ Tags
>
> Tags reconcile Nango's auth-success webhook with the right user, org, or entity in your system. Most apps start with: `end_user_id`, `end_user_email`, `organization_id`.
>
> Tags are also useful for filtering connections via the API and are displayed in the Nango UI. Set the reserved UI tag keys `end_user_display_name` and `end_user_email` to populate the connections list and connection detail page.
>
> See [Connection tags, configuration, and metadata](https://nango.dev/docs/guides/auth/connection-tags-configuration-metadata.md) for more.

`allowed_integrations` controls what the user sees:

* **Multiple integrations** — Connect UI shows a picker.
* **Single integration** — Connect UI sends the user straight to its auth flow.

**6. Trigger the auth flow (frontend)**

Load the Nango frontend SDK, fetch the session token from your backend, and open Connect UI:

![](https://mintcdn.com/nango/AX1oSxxgTaIv9K8E/images/screenshots/connect-ui.gif?s=e00e547fa496a121a9abef98ba8466b4)

Connect UI authorization flow

```js theme={null}
import Nango from '@nangohq/frontend';

const nango = new Nango();
const connect = nango.openConnectUI({
  onEvent: (event) => {
    if (event.type === 'close') {
      // Modal closed.
    } else if (event.type === 'connect') {
      // Auth flow successful.
    }
  },
});

const res = await fetch('/sessionToken', { method: 'POST' });
connect.setSessionToken(res.sessionToken); // A loading indicator shows until this is set.
```

See the [Frontend SDK reference](https://nango.dev/docs/reference/frontend/frontend-sdk.md#connect-using-nango-connect-ui) for more options.

The pre-built Connect UI is recommended but optional — if you need full UX control, follow [Customize Connect UI](https://nango.dev/docs/guides/auth/customize-connect-ui.md). For email/cross-device flows, see [Share a connect link](https://nango.dev/docs/guides/auth/share-connect-link.md).

**7. Listen for webhooks & save the connection ID (backend)**

When authorization succeeds, Nango generates a unique **connection ID**. You use this ID to manage the connection and retrieve its credentials. **You must store it on your side**, attached to the user/org/project that owns the connection — Nango doesn't model that ownership.

Set up the webhook in **Environment Settings**:

1. Specify a **Webhook URL** in the Nango UI.
2. Enable **Send New Connection Creation Webhooks**.
3. Handle `POST` requests on that route in your backend.

> [accordion] For agents
>
> Webhook URL configuration is dashboard-only — there is no public API to set environment webhook URLs. Ask the user to paste the webhook URL into **Environment Settings** and enable **Send New Connection Creation Webhooks**.

Webhook payload:

```json theme={null}
{
  "type": "auth",
  "operation": "creation",
  "success": true,
  "connectionId": "<CONNECTION-ID>",
  "tags": {
    "end_user_id": "<END-USER-ID>",
    "end_user_email": "<END-USER-EMAIL>",
    "organization_id": "<ORGANIZATION-ID>"
  }
}
```

Persist `connectionId` against whichever entity owns the connection in your app.

**8. Build re-authorization**

Credentials can become invalid when users revoke access, providers rotate refresh tokens, scopes change, or an app moves from testing to production. Re-authorization updates an existing connection's credentials while preserving its data and config. Deleting and re-creating the connection wipes that data — prefer re-authorization.

Before showing integration settings, check the connection with `GET /connections/{connectionId}`:

> [tab] Node
>
> ```ts theme={null}
> import { Nango } from '@nangohq/node';
>
> const nango = new Nango({ apiKey: process.env.NANGO_API_KEY! });
>
> try {
>   await nango.getConnection('<INTEGRATION-ID>', '<CONNECTION-ID>');
>   // Connection is valid.
> } catch (error) {
>   if (error.response?.data?.error?.code === 'invalid_credentials') {
>     // Connection is invalid — show a Reconnect button.
>     displayReconnectUI();
>   }
> }
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl --request GET \
>   --url 'https://api.nango.dev/connections/<CONNECTION-ID>?provider_config_key=<INTEGRATION-ID>' \
>   --header 'Authorization: Bearer <NANGO-API-KEY>'
> ```

An `invalid_credentials` error means the connection failed credential refresh or validation — show an error state with a **Reconnect** button.

To trigger re-authorization, use the same frontend flow as a new connection, but generate a reconnect session token on the backend. Pass the returned token to the Frontend SDK exactly like a normal session token. On success you'll receive an `auth` webhook with `operation = override`.

The connection keeps its connection ID. It also keeps its tags, unless the reconnect session passes non-empty `tags` or an `end_user`, which replace them.

> [tab] Node
>
> ```ts theme={null}
> import { Nango } from '@nangohq/node';
>
> const nango = new Nango({ apiKey: process.env.NANGO_API_KEY! });
>
> api.post('/sessionToken', async (req, res) => {
>   const { data } = await nango.createReconnectSession({
>     connection_id: '<CONNECTION-ID>',
>     integration_id: '<INTEGRATION-ID>'
>   });
>
>   res.status(200).send({ sessionToken: data.token });
> });
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl --request POST \
>   --url https://api.nango.dev/connect/sessions/reconnect \
>   --header 'Authorization: Bearer <NANGO-API-KEY>' \
>   --header 'Content-Type: application/json' \
>   --data '{
>     "connection_id": "<CONNECTION-ID>",
>     "integration_id": "<INTEGRATION-ID>"
>   }'
> ```

**9. Run the flow**

Test the auth flow from your app and verify a connection appears in the [Connections](https://app.nango.dev/dev/connections) tab. Failed attempts are inspectable in the **Logs** tab.

> [accordion] For agents
>
> After the user runs the flow, confirm the connection was created with [`GET /connections`](https://nango.dev/docs/reference/backend/http-api/connections/list) — filter by the tags you set in step 5:
>
> ```bash theme={null}
> curl --request GET \
>   --url 'https://api.nango.dev/connections?tags[end_user_id]=<END-USER-ID>' \
>   --header 'Authorization: Bearer <NANGO-API-KEY>'
> ```
>
> Auth logs are dashboard-only — if the call returns no connection, ask the user to check the **Logs** tab for the failure reason.

🎉 **You are connected!** Next:

* View connections and credentials in the **Connections** tab.
* Retrieve credentials via the [API](https://nango.dev/docs/reference/backend/http-api/connections/get.md) or [Node SDK](https://nango.dev/docs/reference/backend/backend-sdk/node.md#get-a-connection-with-credentials).
* Build with [sync functions](https://nango.dev/docs/guides/functions/syncs/sync-functions.md), [Tools](https://nango.dev/docs/guides/functions/tools.md), [webhook functions](https://nango.dev/docs/guides/functions/webhook-functions.md), or any other Nango function type.

> [!TIP]
>
> **Questions, problems, feedback?** Reach out in the [Slack community](https://nango.dev/slack).

## Nango-managed OAuth apps

Many OAuth APIs have a Nango-managed OAuth app: a pre-approved OAuth app that Nango registers and maintains with the provider. You can use it to connect users without registering an app yourself.

Nango-managed OAuth apps are production-ready. They let you launch faster and support many APIs at once, because you don't register an app or wait for provider approval for each API.

They come with some tradeoffs:

* **Whitelabel auth** — with a Nango-managed app, the consent screen shows Nango, not your product.
* **Scopes** — Nango-managed apps have fixed scopes. Your own app can request any scope the provider offers.
* **Callback URL** — Nango-managed apps use Nango's callback URL. Your own app can use a [custom callback URL](#custom-oauth-callback-url-optional) on your domain.
* **Marketplace listings** — provider marketplaces require your own app.
* **Revocation risk** — if a provider revokes a Nango-managed app, every connection using it stops working.
* **Portability** — only with your own app can you export access and refresh tokens and move off Nango without users re-authorizing.

These tradeoffs apply to shared OAuth apps from any auth platform, not just Nango.

To make registering your own app easier, Nango maintains step-by-step setup guides for most OAuth APIs in [APIs & Integrations](https://nango.dev/docs/integrations/overview.md), for example [Gmail](https://nango.dev/docs/api-integrations/google-mail/how-to-register-your-own-gmail-api-oauth-app).

### APIs with a Nango-managed OAuth app

We add more OAuth apps every week. If an API you need is missing, please contact us and we will do our best to add it.

> [accordion] List of APIs with a Nango-managed OAuth app (84)
>
> * [Acuity Scheduling](https://nango.dev/docs/integrations/all/acuity-scheduling.md)
> * [Airtable](https://nango.dev/docs/api-integrations/airtable.md)
> * [Asana](https://nango.dev/docs/api-integrations/asana.md)
> * [Basecamp](https://nango.dev/docs/integrations/all/basecamp.md)
> * [Bitbucket](https://nango.dev/docs/integrations/all/bitbucket.md)
> * [BoldSign](https://nango.dev/docs/integrations/all/boldsign.md)
> * [Box](https://nango.dev/docs/api-integrations/box.md)
> * [Cal.com (OAuth)](https://nango.dev/docs/api-integrations/cal-com-oauth.md)
> * [Calendly](https://nango.dev/docs/api-integrations/calendly.md)
> * [ClickUp](https://nango.dev/docs/api-integrations/clickup.md)
> * [Close](https://nango.dev/docs/integrations/all/close.md)
> * [Confluence](https://nango.dev/docs/api-integrations/confluence.md)
> * [Contentful](https://nango.dev/docs/integrations/all/contentful.md)
> * [Discord](https://nango.dev/docs/api-integrations/discord.md)
> * [Eventbrite](https://nango.dev/docs/integrations/all/eventbrite.md)
> * [Exist](https://nango.dev/docs/integrations/all/exist.md)
> * [Facebook](https://nango.dev/docs/api-integrations/facebook.md)
> * [GitHub (App)](https://nango.dev/docs/api-integrations/github-app.md)
> * [GitHub (User OAuth)](https://nango.dev/docs/api-integrations/github.md)
> * [GitLab](https://nango.dev/docs/integrations/all/gitlab.md)
> * [Gmail](https://nango.dev/docs/api-integrations/google-mail.md)
> * [Google Ads](https://nango.dev/docs/api-integrations/google-ads.md)
> * [Google Calendar](https://nango.dev/docs/api-integrations/google-calendar.md)
> * [Google Drive](https://nango.dev/docs/api-integrations/google-drive.md)
> * [Google Sheets](https://nango.dev/docs/api-integrations/google-sheet.md)
> * [Google Tasks](https://nango.dev/docs/api-integrations/google-tasks.md)
> * [Gumroad](https://nango.dev/docs/integrations/all/gumroad.md)
> * [HubSpot](https://nango.dev/docs/api-integrations/hubspot.md)
> * [Hubstaff](https://nango.dev/docs/api-integrations/hubstaff.md)
> * [Intercom](https://nango.dev/docs/api-integrations/intercom.md)
> * [Jira (OAuth)](https://nango.dev/docs/api-integrations/jira.md)
> * [Judge.me (OAuth)](https://nango.dev/docs/api-integrations/judgeme-oauth.md)
> * [Linear](https://nango.dev/docs/api-integrations/linear.md)
> * [LinkHut](https://nango.dev/docs/integrations/all/linkhut.md)
> * [Mailchimp](https://nango.dev/docs/integrations/all/mailchimp.md)
> * [Microsoft](https://nango.dev/docs/api-integrations/microsoft.md)
> * [Microsoft Entra ID](https://nango.dev/docs/integrations/all/microsoft-entra-id.md)
> * [Microsoft Excel](https://nango.dev/docs/integrations/all/microsoft-excel.md)
> * [Microsoft People](https://nango.dev/docs/api-integrations/microsoft-people.md)
> * [Microsoft Power BI](https://nango.dev/docs/integrations/all/microsoft-power-bi.md)
> * [Microsoft PowerPoint](https://nango.dev/docs/api-integrations/microsoft-powerpoint.md)
> * [Microsoft Teams](https://nango.dev/docs/api-integrations/microsoft-teams.md)
> * [Microsoft Word](https://nango.dev/docs/api-integrations/microsoft-word.md)
> * [Miro](https://nango.dev/docs/integrations/all/miro.md)
> * [Monday](https://nango.dev/docs/api-integrations/monday.md)
> * [Moneybird](https://nango.dev/docs/api-integrations/moneybird.md)
> * [Mural](https://nango.dev/docs/integrations/all/mural.md)
> * [Notion](https://nango.dev/docs/api-integrations/notion.md)
> * [OneDrive for Business](https://nango.dev/docs/api-integrations/one-drive.md)
> * [OneDrive Personal](https://nango.dev/docs/integrations/all/one-drive-personal.md)
> * [OneNote](https://nango.dev/docs/integrations/all/one-note.md)
> * [Outline](https://nango.dev/docs/api-integrations/outline.md)
> * [Outlook](https://nango.dev/docs/api-integrations/outlook.md)
> * [Pinterest](https://nango.dev/docs/integrations/all/pinterest.md)
> * [Pipedrive](https://nango.dev/docs/api-integrations/pipedrive.md)
> * [Quickbooks](https://nango.dev/docs/api-integrations/quickbooks.md)
> * [Quickbooks (Sandbox)](https://nango.dev/docs/api-integrations/quickbooks-sandbox.md)
> * [Salesforce](https://nango.dev/docs/api-integrations/salesforce.md)
> * [SharePoint Online (v2)](https://nango.dev/docs/api-integrations/sharepoint-online.md)
> * [Slack](https://nango.dev/docs/api-integrations/slack.md)
> * [Smartsheet](https://nango.dev/docs/api-integrations/smartsheet.md)
> * [Splitwise](https://nango.dev/docs/integrations/all/splitwise.md)
> * [Stack Exchange](https://nango.dev/docs/integrations/all/stackexchange.md)
> * [Strava (Web)](https://nango.dev/docs/integrations/all/strava-web.md)
> * [TickTick](https://nango.dev/docs/integrations/all/ticktick.md)
> * [Timely](https://nango.dev/docs/integrations/all/timely.md)
> * [Todoist](https://nango.dev/docs/integrations/all/todoist.md)
> * [Twitch](https://nango.dev/docs/integrations/all/twitch.md)
> * [Typeform](https://nango.dev/docs/api-integrations/typeform.md)
> * [Wakatime](https://nango.dev/docs/integrations/all/wakatime.md)
> * [Webex](https://nango.dev/docs/integrations/all/webex.md)
> * [Wrike](https://nango.dev/docs/integrations/all/wrike.md)
> * [YouTube](https://nango.dev/docs/api-integrations/youtube.md)
> * [Zendesk](https://nango.dev/docs/api-integrations/zendesk.md)
> * [Zoho](https://nango.dev/docs/integrations/all/zoho.md)
> * [Zoho Bigin](https://nango.dev/docs/integrations/all/zoho-bigin.md)
> * [Zoho Books](https://nango.dev/docs/integrations/all/zoho-books.md)
> * [Zoho Calendar](https://nango.dev/docs/integrations/all/zoho-calendar.md)
> * [Zoho CRM](https://nango.dev/docs/api-integrations/zoho-crm.md)
> * [Zoho Desk](https://nango.dev/docs/integrations/all/zoho-desk.md)
> * [Zoho Inventory](https://nango.dev/docs/integrations/all/zoho-inventory.md)
> * [Zoho Invoice](https://nango.dev/docs/integrations/all/zoho-invoice.md)
> * [Zoho Mail](https://nango.dev/docs/integrations/all/zoho-mail.md)
> * [Zoho People](https://nango.dev/docs/integrations/all/zoho-people.md)

## Related guides

* [Share a connect link](https://nango.dev/docs/guides/auth/share-connect-link.md) - send authorization links by email, support tools, or cross-device flows.
* [Connection tags, configuration, and metadata](https://nango.dev/docs/guides/auth/connection-tags-configuration-metadata.md) - store the right connection-level data in the right field.
* [Customize Connect UI](https://nango.dev/docs/guides/auth/customize-connect-ui.md) - customize branding or build your own authorization UI.
* [Token refreshing and validity](https://nango.dev/docs/guides/auth/token-refreshing.md) - handle revoked or expired credentials.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.