nango

Nango is an open-source platform that enables developers to build, run, and maintain product integrations with 800+ APIs using TypeScript functions and AI-generated code. It handles authentication, request proxying, and scalable execution so engineering teams can focus on integration logic rather than infrastructure plumbing.

At its core, Nango offers three primitives: Auth (managed OAuth, API keys, and token refresh), Proxy (authenticated API requests with automatic retries and rate-limit handling), and Functions (TypeScript-based integration logic deployed to a production runtime). These primitives cover every common integration pattern, from bidirectional data syncs to AI agent tool calling and webhook processing.

Nango is designed for production workloads, processing billions of API requests with per-tenant isolation, elastic scaling, and OpenTelemetry-based observability built in. It integrates natively with AI coding tools like Cursor and Claude Code, and works with agent SDKs such as LangChain and MCP. Used in production by Replit, Ramp, Mercor, and hundreds of other companies.

What You Get

• 800+ Pre-Built API Connectors - Managed OAuth, API key, and token refresh flows for APIs like Google, Slack, Salesforce, GitHub, and hundreds more, with connection state and multi-tenant credential storage handled automatically.
• AI Integration Builder - Generate TypeScript sync and action functions from natural language descriptions using AI, producing readable, type-safe, version-controllable code you can review and edit.
• Unified API Proxy - Route authenticated requests to any connected API through a single endpoint that automatically resolves credentials, handles retries on transient failures, and manages rate limits.
• TypeScript Functions Runtime - Write and deploy custom syncs, actions, and webhook processors as TypeScript functions with built-in access to the Nango SDK, storage, structured logging, and OpenTelemetry tracing.
• Scheduled Bidirectional Data Sync - Run incremental or full syncs in both directions with pagination, batch saving via nango.batchSave, and precise delete tracking via nango.trackDeletesStart/End.
• Universal Webhook Processor - Receive, validate, and route webhooks from any external API through a single ingestion endpoint with delivery guarantees and configurable retry behavior.
• Per-Customer Configuration - Store and retrieve dynamic configuration data per connection, enabling multi-tenant integrations where each customer can have different API credentials, scopes, or behavior.
• CLI and CI/CD Toolchain - Scaffold, dry-run, test, and deploy integrations using the Nango CLI (nango create, nango dryrun, nango deploy) with full Git compatibility and pipeline support.

Common Use Cases

• AI Agent Tool Calling - An AI assistant uses Nango’s MCP integration to call Google Calendar, GitHub, or Salesforce APIs on behalf of end users, with OAuth handled transparently per user session.
• SaaS Data Sync for RAG Pipelines - A startup syncs customer support tickets from Zendesk and emails from Gmail into a vector store for AI-powered search, using Nango’s scheduled syncs with incremental pagination.
• Multi-Tenant API Unification - A B2B platform normalizes CRM data from Salesforce, HubSpot, and Pipedrive into a single internal schema for its analytics dashboard, using per-customer config and Nango’s proxy layer.
• Automated Webhook Processing - A fintech application receives and processes payment events from Stripe, bank webhooks from Plaid, and compliance updates from third-party providers through Nango’s universal webhook endpoint.
• White-Label OAuth Embedding - A developer tool embeds Nango’s Connect UI to let users authorize integrations without exposing OAuth credentials or building custom auth flows for each provider.
• Enterprise Integration Pipeline - An HR platform syncs employee data between their product and ADP, Workday, and BambooHR using Nango’s action functions and bidirectional sync with tenant isolation.

Under The Hood

Architecture Nango is structured as a large-scale TypeScript monorepo with over 30 purpose-built packages, each with strict dependency boundaries enforced via workspace isolation. The system follows a service-oriented architecture: a central HTTP server handles inbound API and OAuth flows, an orchestrator manages task scheduling via PostgreSQL LISTEN/NOTIFY, and independent runner services execute TypeScript function payloads in isolated environments. Feature flag evaluation is wired through an OpenFeature-compatible client that can swap between a no-op provider and Unleash at runtime, enabling progressive rollout without code changes. Credential encryption is handled by a dedicated KMS package that resolves a Data Encryption Key from environment variables or AWS KMS at startup and keeps it only in memory, never on disk. The result is a system where auth, execution, observability, and billing are cleanly separated services that can be scaled and deployed independently.

Tech Stack Nango’s backend runs on Node.js 22 with TypeScript throughout, compiled via tsc and orchestrated with npm workspaces. PostgreSQL serves as the primary datastore for connections, sync state, and task queues, with Knex.js providing type-safe query building and migration management. Redis powers pub/sub event distribution and serves as a key-value store via the dedicated kvstore package. The frontend applications — including the web dashboard and the embeddable Connect UI — are built with React and Vite. Integration functions execute in a sandboxed runner environment with access to the runner SDK, which exposes typed helpers for pagination, batching, checkpointing, and HTTP requests. Observability is provided via OpenTelemetry with structured logging through a shared utils package. Deployment targets include Docker Compose for local development and Kubernetes via Helm charts for production.

Code Quality The codebase demonstrates strong engineering discipline. Test files follow a clear naming convention (*.unit.test.ts and *.integration.test.ts), and tests are distributed across packages including the orchestrator, database, KMS, node client, billing, and persist layers. TypeScript is used strictly across all packages with no permissive type overrides. ESLint and Prettier enforce consistent formatting with Husky pre-commit hooks. Error handling is explicit and typed, with structured error responses, retry-with-backoff utilities, and guard clauses at service boundaries. The KMS and encryption modules in particular show careful attention to security properties — DEK resolution is cached to run once per process and keys are never written to disk or logs. The monorepo structure and shared type packages ensure that inter-service contracts are validated at compile time.

What Makes It Unique Nango’s core innovation is treating integration infrastructure as a production platform concern rather than a per-project implementation task. The combination of 800+ pre-wired OAuth connectors, a typed TypeScript function runtime with AI code generation, and a self-contained execution layer with per-tenant isolation means teams can ship integrations that would normally take months in days. The KMS-backed credential encryption with in-memory-only DEK handling addresses a real security gap in most self-hosted integration tools. The PostgreSQL-backed task scheduler with LISTEN/NOTIFY-driven orchestration avoids external message broker dependencies while still providing durable, ordered task execution at scale. This architecture, combined with native AI agent compatibility via MCP and LangChain, positions Nango ahead of alternatives that handle only auth or only proxying.

Self-Hosting

Nango is licensed under the Elastic License 2.0 (ELv2). This license grants broad usage rights — you can use, copy, distribute, and modify the software freely for internal purposes, including commercial use within your own products. The key restriction is that you may not offer Nango itself as a hosted or managed service to third parties. If you are building a product that uses Nango internally to power your own integrations, ELv2 is permissive. If you intended to resell Nango as a managed integration platform, you would need a commercial agreement with Nango HQ.

Self-hosting Nango requires orchestrating multiple services: a PostgreSQL database, Redis, and at least three Node.js services (server, jobs/orchestrator, runner). Docker Compose configurations are provided for local development and Kubernetes Helm charts for production deployments. Operationally, your team is responsible for uptime, database backups, schema migrations, Redis availability, and rolling upgrades — the project ships new versions at roughly twice-weekly cadence, so staying current requires an active operations practice. The runner packages are particularly resource-sensitive since they execute untrusted TypeScript functions in sandboxed environments.

Nango Cloud offers a fully managed tier that includes all infrastructure management, SOC 2 Type II and HIPAA compliance documentation, SLA-backed uptime, managed upgrades, and enterprise support channels. The Cloud plan also provides access to paid features including advanced observability dashboards, higher connection and execution limits, and dedicated runner capacity. The free self-hosted tier runs the full open-source codebase but lacks access to Nango’s AI builder, enterprise SSO, and advanced compliance features. Teams evaluating self-hosting should weigh the engineering overhead of maintaining a multi-service stateful system against the cost savings versus the managed cloud offering.