Nango

Open-source integration infrastructure, honestly reviewed. Built for engineering teams, not marketing interns.

TL;DR

• What it is: Developer infrastructure for building product integrations — OAuth, API proxying, sync, and TypeScript functions for 700+ APIs. You ship integrations to your customers; Nango handles the plumbing [README][3].
• Who it’s for: Engineering teams at B2B SaaS companies who need to offer integrations with Salesforce, HubSpot, Slack, GitHub, and hundreds of other tools to their own customers. This is not a Zapier replacement for non-technical founders — it’s infrastructure for developers building the next Zapier [2][4].
• Key strength: Pre-built auth flows for 700+ APIs, a code-first TypeScript function runtime, an AI builder that generates integration code, and a built-in MCP server. Used in production by Replit, Ramp, Vapi, and Motion [README][3].
• Key weakness: Elastic license (not MIT, not Apache) means you can self-host for your own use but can’t resell Nango as a managed service. Pricing scales by connection count — which gets expensive fast in multi-tenant SaaS. No pre-built unified data models; you define your own schemas [2][4].
• Cost reality: Free tier covers 10 connections and 100K proxy requests. Starter is $50/month. Growth is $500/month. Self-hosting is an option but means owning uptime, scaling, and security yourself [3].

---

What is Nango

Nango is a developer platform for building the integrations that live inside your product — the kind where your customer clicks “Connect Salesforce” and your app starts syncing their contacts. It’s not a workflow automation tool for your own internal processes. It’s infrastructure you embed in a SaaS product to offer integrations to your end users.

The company describes it as “build product integrations with AI” and the pitch is straightforward: instead of writing OAuth flows, token refresh logic, rate-limit handling, pagination, and observability from scratch for every API you need to support, you use Nango as the runtime and write only the integration logic itself [README].

Three primitives cover the full surface area [README]:

Auth. Managed OAuth, API keys, and token refresh for 700+ APIs. Nango handles credential storage, multi-tenant connection management, and the white-label auth UI your customers see when they connect their accounts.

Proxy. Authenticated API requests on behalf of your users. You send requests through Nango’s proxy; it resolves the provider, injects credentials, handles retries and rate limits, and returns the response. Your app never stores raw OAuth tokens.

Functions. TypeScript functions that define your integration logic — syncs that pull data on a schedule, actions that write data back, webhook handlers that react to external events. Deploy them to Nango’s runtime or self-host the whole stack.

The AI builder angle is real, not marketing. You can prompt it to generate a sync function from a natural language description, test it locally with the CLI against a real API connection, and deploy when it looks right [website][README]. Used in production by Replit, Ramp, Mercor, and Vapi — Vapi’s founding engineer cited it as the reason they could go “from zero to 60+ integrations in weeks, syncing tens of millions of jobs a month without breaking a sweat” [website].

As of this review, the GitHub repository sits at 6,897 stars. The company was founded in 2022, is based in San Francisco, and has raised $9.63M+ [3].

---

Why people choose it

The honest answer from third-party sources is that people choose Nango to avoid writing OAuth and token refresh code. That sounds narrow, but if you’ve done it twice you know it’s genuinely miserable work — every API has edge cases, token storage has security implications, and you’ll spend weeks on auth plumbing instead of product features.

Composio’s comparison piece [2] frames Nango’s strongest case as OAuth credential management, calling it “a solid open-source tool for handling OAuth flows” — that’s accurate praise and accurate scope definition. Where Composio pushes back is on what happens next: “as you move from proof-of-concept to production, especially when you’re building AI agents or scalable B2B SaaS integrations, authentication is just the beginning.” Nango’s paid tiers address this with functions, syncs, and webhooks — but the free tier is auth and proxy only, which shapes how people initially perceive the product [2].

GetKnit’s comparison [4] notes genuine strengths: “Straightforward Setup: Shortens integration development cycles with a simplified approach” and “Embedded Integration Model: Helps you provide native integrations directly within your product.” The criticism is also fair: “Limited Coverage Beyond Core Apps: May not support the full depth of specialized or industry-specific APIs” and “Standardized Data Models: With Nango you have to create your own standard data models which requires some learning curve” [4].

Nango’s own engineering blog [1] offers an unusual window into how the company operates. Their post on migrating from Temporal to a Postgres-based task orchestrator shows an engineering team that reasons carefully about tradeoffs and doesn’t cargo-cult infrastructure. They found Temporal to be “a pretty expensive and complex queuing and scheduling system” for their use case — running untrusted user-code that couldn’t leverage Temporal’s resume semantics — and built their own Postgres queue instead of picking the next shiny thing. That kind of decision-making discipline shows up in how the product itself is structured.

---

Features

Based on the README, website, and third-party sources:

Auth and connections:

• Pre-built OAuth 1.0/2.0, API key, and basic auth flows for 700+ APIs [README]
• White-label connect UI embeddable in your frontend [README]
• Automatic token refresh and credential rotation [3]
• Multi-tenant connection management — each of your customers gets their own isolated credential set [README]
• Webhook notifications when credentials become invalid [3]

Proxy:

• Authenticated API requests with automatic credential injection [README]
• Built-in retry logic and rate limit handling [README]
• Sub-100ms execution latency [website]

Functions (the integration runtime):

• TypeScript-based syncs, actions, and webhook handlers [README]
• AI builder that generates function code from natural language descriptions [website][README]
• Local development with CLI, hot reload, and nango dryrun for testing against real connections [website]
• Git-trackable — functions live in your codebase [website]
• Auto-scaling runtime; elastic infrastructure handles traffic spikes [website]
• Built-in pagination, retries, and observability [README]

AI and agent tooling:

• LLM tool calling: expose your integrations to AI agents [README][3]
• Built-in MCP server — your Nango integrations become MCP tools consumable by Claude Desktop, Cursor, or any MCP client [README][3]
• Works with any agent SDK [README]

Data syncing:

• Two-way syncs for RAG pipelines, indexing, and triggers [README][3]
• Webhook processing with a universal interface across APIs [README]
• API unification — normalize different APIs to a common schema you define [README]
• Per-customer configuration — customize integration behavior per tenant [README]

Observability:

• Real-time logs and metrics [3]
• OpenTelemetry integration [README]
• Detailed execution history per integration and per customer connection [3]

What you don’t get without paying:

• More than 10 API auth connections (free tier cap) [3]
• More than 100K proxy requests/month on free tier [3]
• Two-way syncing, MCP, API unification, and UI components all require paid Starter tier ($50/mo minimum) [3]

---

Pricing: SaaS vs self-hosted math

Nango Cloud (managed service):

• Free: 10 API auth connections, 100K proxy requests, 10 hours functions compute, 100K function runs — useful for development and proof of concept [3]
• Starter: $50/month — 20 connections included, then $1/connection; 200K proxy requests, then $0.0001/request; 200K function runs; two-way syncing; MCP; SOC 2 Type II [3]
• Growth: $500/month — 100 connections, 1M proxy requests, priority support, 7-day SLA for new API support [3]
• Enterprise: Custom pricing, contact sales [3]

The connection pricing deserves scrutiny. Each “connection” is one of your customers connecting their external account — so if you have 30 customers and they each connect Salesforce, that’s 30 connections. On the Starter plan you get 20 included, then pay $1/connection/month for each additional. At 100 customers with one integration each, you’re looking at $80/month on top of the $50 base = $130/month just for auth. Add a second integration per customer and you’re at $210/month [3].

That math changes the comparison. This isn’t “pay $50/month forever” — it’s “pay $50/month plus $1 per customer-integration connection.” For an early-stage SaaS with 10 customers, the Starter tier is generous. At 200 customers with multiple integrations each, you’re well into Growth territory at $500/month plus overages.

Self-hosted:

• The license is Elastic, not MIT or Apache [README badge]. You can self-host Nango for your own use without paying. You cannot offer Nango as a hosted service to others or include it in a competing product.
• Infrastructure cost to self-host: a VPS with at least 4GB RAM for the Nango server, Postgres, and Redis. Call it $20–40/month on Hetzner or DigitalOcean.
• Hidden cost: your engineering team owns uptime, scaling, security patching, and connector updates. Composio’s analysis [2] puts this plainly: “That ‘free’ license can hide a lot of operational costs” including “developer hours for setup, maintenance, and troubleshooting.”

The real cost question isn’t “cloud vs self-host.” It’s “build your own OAuth + proxy + sync infrastructure vs. use Nango.” A senior engineer spending two weeks building robust OAuth for five APIs costs far more than a year of Nango Starter. That’s the actual comparison [2].

---

Deployment reality check

Self-hosting Nango is documented but not simple. The stack requires Postgres and Redis in addition to the Nango server itself. The README points to Docker Compose for local dev; production deployment adds a reverse proxy, SMTP, and secrets management.

What can go sideways [1][2]:

The company moved away from Temporal entirely and built their own Postgres-based queue [1] — an architectural decision that reduces external dependencies for self-hosters but means you’re running custom infrastructure with less community documentation than, say, a Postgres + Sidekiq setup.

Composio’s analysis [2] is direct about the TCO risk: “Self-hosting means your team handles uptime, scaling, security patches, and connector updates. You also need to achieve and maintain compliance certifications like SOC 2. A managed platform should offer SOC 2 / GDPR compliance, secure credential storage, and automatic token refreshes out-of-the-box. That alone can cut your operational costs dramatically.”

For a startup with a two-person engineering team shipping integrations as a feature, self-hosting Nango is probably the wrong call — the operational overhead isn’t worth it until you have dedicated infrastructure capacity. For a team of 10+ engineers with a DevOps function, it’s viable.

The Elastic license is also worth re-reading before you commit. The restriction isn’t about self-hosting your own product — that’s allowed. The restriction is on building a competing integration platform on top of Nango. Most SaaS teams won’t hit this constraint, but legal should sign off before you build a reseller or white-label offering on it.

---

Pros and cons

Pros

• 700+ pre-built auth flows. The time saved not writing OAuth for each API is real. Every major SaaS API (Salesforce, HubSpot, Slack, GitHub, Google, Stripe) has a tested auth flow ready to embed [README].
• Code-first, git-native. Integration logic lives in your codebase, deploys via CLI, and is reviewable and rollback-able like any other code. This is the right model for engineering teams [website][README].
• AI code generation for integrations. The AI builder generates TypeScript functions from descriptions and the API’s actual documentation — not generic code but code that matches the specific API’s pagination and data shapes [website].
• MCP server built-in. Every integration you build is automatically exposable as an MCP tool to AI agents. This is useful if you’re building agent-powered workflows on top of external APIs [README][3].
• SOC 2 Type II on managed cloud. Compliance teams can sign off on the credential storage without custom audit work [3].
• Used in real production at scale. Vapi runs integrations inline during live calls — latency-sensitive production use, not a toy [website].

Cons

• Not MIT licensed. The Elastic license is more restrictive than MIT or Apache. You can self-host and use it internally, but read the license before building any product that involves offering Nango’s functionality to others [README].
• Connection-count pricing gets expensive. $1/connection/month sounds cheap until you have 300 customers each with 3 integrations = $900/month in connection fees on top of the base plan [3].
• No pre-built unified data models. Unlike Merge or Knit, Nango doesn’t normalize a “contact” across Salesforce, HubSpot, and Pipedrive for you. You define your own schemas. More flexible, more work [2][4].
• Not for non-technical teams. This product requires TypeScript. You write integration logic as code. There’s no drag-and-drop builder. A non-technical founder cannot use this without an engineer [README].
• Free tier is narrow. 10 connections and 100K proxy requests is enough to build and demo a proof of concept, not to run a small production SaaS [3].
• Support wall on lower tiers. GetKnit notes that “if you need support you may have to take their enterprise plans” [4] — the Starter tier doesn’t include priority support.
• Self-hosting TCO underestimated in marketing. The “open source” framing undersells the operational cost of running Nango’s custom Postgres queue, keeping connectors updated, and managing security [1][2].

---

Who should use this / who shouldn’t

Use Nango if:

• You’re an engineering team at a B2B SaaS company building customer-facing integrations (Salesforce sync, Slack notifications, GitHub automation) and you don’t want to reinvent OAuth and token management for each API.
• You’re building AI agents that need to act on real SaaS data and want MCP-compatible tooling over 700+ APIs without writing the connectors yourself.
• You have the TypeScript skills to write integration logic and want a structured runtime that handles the rest.
• You’re past proof-of-concept and need production infrastructure with observability and SOC 2 compliance.

Skip it (build your own) if:

• You need exactly two integrations and they’re simple REST APIs with API key auth. The setup overhead isn’t worth it at that scale.
• Your compliance team has concerns about Elastic-licensed infrastructure components in your product — get legal to review the license first.

Skip it (pick Merge or Knit) if:

• You need normalized data models across multiple SaaS categories (HRIS, CRM, ATS, accounting). Merge and Knit deliver unified APIs with pre-built schemas so you don’t define your own [2][4].
• You want a managed, fully hands-off integration layer with no TypeScript required and unified endpoints per category.

Skip it entirely if:

• You’re a non-technical founder trying to automate your own workflows. Use Activepieces or n8n. Nango is for engineers building products, not operators automating processes [2][README].
• You want to resell a managed integration service built on Nango — the Elastic license prohibits this [README].

---

Alternatives worth considering

From third-party comparisons [2][4]:

• Composio — positioned as the “agent-native” alternative. Managed SDK, pre-built actions and triggers, handles auth. Strong choice if you’re building AI agents and don’t want to write integration logic at all [2].
• Merge.dev — unified API platform for HRIS, ATS, CRM, accounting, and ticketing. Pre-built normalized data models across categories. Higher abstraction, less flexibility, but much faster for category-specific integrations [2][4].
• Paragon — low-code + pro-code embedded integration platform. Closer to Nango’s use case but with a visual builder alongside the code option. Good for teams with mixed technical profiles [2].
• Pipedream — developer-focused, code-first, partially open source. Works well for workflow automation in your own backend; less focused on multi-tenant customer-facing integrations [2].
• Knit — B2B SaaS integration platform with event-driven architecture that avoids storing end-user data (privacy-first design). Builds new connectors in 2–3 days on request [4].
• Tray Embedded — enterprise-grade embedded integration platform. More expensive, more mature, better for large enterprise buyers [4].
• Build it yourself — viable if you need fewer than 5 integrations with stable APIs. The switching cost to Nango increases the more custom OAuth edge-case logic you’ve already written.

For a B2B SaaS team choosing between Nango and Merge: pick Nango if you need code-level control over integration logic and want flexibility. Pick Merge if you’re in one of the standard categories (HR, CRM, accounting) and want to skip schema definition entirely.

---

Bottom line

Nango solves a real and painful problem: building robust, multi-tenant, production-grade integrations with external APIs is expensive engineering work, and Nango compresses that timeline substantially by handling auth, credential management, scaling, and observability as managed infrastructure. The TypeScript functions model, local CLI development, and AI builder make the experience feel close to writing regular application code rather than fighting API-specific auth quirks. The production endorsements from Replit, Vapi, and Ramp are credible signal that this isn’t demo-ware.

The caveats are real too. The Elastic license is not MIT — read it before you build on it commercially. The connection-count pricing model means costs scale with your customer base in a way that can surprise you. And if you’re a non-technical founder looking to automate your internal operations, Nango is the wrong tool — it’s infrastructure for engineers building products, not a drag-and-drop automation platform.

For the right audience — a small engineering team at a SaaS startup that needs to ship five to fifty integrations and doesn’t want to write OAuth and retry logic from scratch — the Starter plan at $50/month is genuinely cheap compared to the engineer-weeks it replaces.

---

Sources

1. Nango Blog — “Migrating from Temporal to a Postgres-based task orchestrator”. https://www.nango.dev/blog/migrating-from-temporal-to-a-postgres-based-task-orchestrator
2. Composio — “7 best Nango alternatives for AI agents and API integrations (2026)”. https://composio.dev/blog/nango-alternatives-ai-agents
3. EveryDev.ai — “Nango - Product Integration Infrastructure” (pricing and feature details). https://www.everydev.ai/tools/nango
4. GetKnit.dev — “Top 5 Nango Alternatives”. https://www.getknit.dev/blog/top-5-nango-dev-alternatives

Primary sources:

• GitHub repository and README: https://github.com/nangohq/nango (6,897 stars, Elastic license)
• Official website: https://nango.dev
• Documentation: https://nango.dev/docs/
• Integration catalog: https://nango.dev/docs/integrations/overview/