> ## Content Index > Fetch the complete content index at: https://www.angularspace.com/llms.txt > Use this file to discover other available public pages before exploring further. # The best API integration platforms for SaaS apps and agents in 2026 - URL: https://www.angularspace.com/best-api-integration-platforms-for-saas-and-agents/ - Published: 2026-08-26T17:40:00.000Z - Updated: 2026-08-28T13:54:46.000Z - Description: A hands-on guide for Angular and TypeScript teams. compared six platforms and focused on how easily each fits into an Angular app and how much backend control you retain when an integration goes beyond the standard flow. - Author: Emmanuel *A hands-on guide for Angular and TypeScript teams.* Let's say you've built a B2B SaaS product and your first enterprise prospect asks, "Does it integrate with Salesforce?" The next prospect asks about HubSpot, and the one after that about NetSuite. You can build each integration in-house, but every one takes engineering time away from the product. Building integrations in-house means handling OAuth flows, token refresh, rate limits, pagination, and webhooks separately for every API your customers use. The alternative is an embedded integration platform: infrastructure you ship inside your product that lets each customer connect their own tools from your settings page. I compared six platforms by reviewing their SDKs and documentation. I focused on how easily each fits into an Angular app and how much backend control you retain when an integration goes beyond the standard flow. ## What's the best SDK or API for embedding third-party app integrations into a SaaS product? Nango is best for engineering teams building deep, custom integrations. It has a pre-built catalog of 900+ APIs. Engineers write the integration logic in code and can customize it for each API. Nango Cloud runs these integrations at enterprise scale, while self-hosting and BYOC (bring your own cloud) are available on an Enterprise plan. However, Merge fits teams that need unified APIs with fixed data models, rather than deep, custom object access in their APIs. Paragon and Prismatic let teams build workflows visually. Apideck provides real-time unified APIs across seven categories. Pipedream Connect requires less setup for quick prototypes and long-tail APIs. ## TL;DR - **Nango:** Best for engineering teams that need a broad API catalog and full control over their integration logic. - **Merge:** Best for teams that need unified APIs with fixed data models, rather than deep, custom object access. - **Paragon:** Best for non-technical teams that prefer low-code visual workflows for building integrations, though lower plans have stricter execution limits. Prismatic is designed around embeddable workflows. Apideck provides broad unified API coverage, while Pipedream Connect is useful for prototypes and less common APIs. See the [comparison table](#comparison-of-embedded-integration-platforms) for a side-by-side summary. ## What is an embedded integration platform? An embedded integration platform (also called an embedded integration platform as a service, or embedded iPaaS) adds customer-facing account connections to your product. A customer can connect Salesforce from your settings page while the platform handles OAuth, credential storage, token refresh, retries, and rate limits behind the scenes. Zapier and Make are built for people automating their own accounts. An embedded platform instead helps a SaaS company offer integrations as part of its product. ## What is a unified API and how does it work? A unified API exposes one schema across several providers in the same category. Your app calls the vendor's contact endpoint, for example, and the vendor translates that request for Salesforce, HubSpot, or Pipedrive. That shared schema works well for standard fields. Custom fields, provider-specific settings, and objects that do not map cleanly usually require field mapping, raw data, or passthrough requests. The available options vary by vendor and plan. ## Native integrations vs unified APIs vs embedded iPaaS: when each fits Most teams choose one of three approaches: - **Native integrations built in-house:** building natively gives you full API access, but your team owns [authentication](https://nango.dev/blog/why-is-oauth-still-hard?ref=angularspace.com), token refresh, rate limits, and ongoing maintenance for each provider. Sensible when you need only one or two integrations and they are your core product. - **Unified APIs (Merge, Apideck):** fastest path to covering a category with standard data. The fixed schema works until a customer asks for a custom field, a provider-specific endpoint, or a category the vendor does not cover. - **Embedded integration platforms (Nango, Paragon, Prismatic, Pipedream Connect):** the platform handles auth and infrastructure across a large catalog, while integration logic stays yours, either as code or as visual workflows depending on the platform. Choose an embedded integration platform when you need more control than a unified API provides but do not want to build the authentication and execution infrastructure yourself. Some vendors fall into more than one of these categories. Ask whether standard categories and fields will still cover your needs a year from now. If they will, a unified API is usually the quickest route. If customers are likely to need provider-specific behavior, choose a platform that leaves the integration logic under your control. ## How we evaluated these platforms I evaluated each platform using eight criteria: 1. **Developer experience and control:** code-first or low-code, TypeScript support, and whether engineers can customize any part of an integration or hit a wall. I also looked for a local development workflow and for abstractions you can drop below when a requirement does not fit. 2. **Frontend embedding quality:** the actual SDK story, meaning the auth and connect UI components each platform ships, any headless option, how the OAuth popup and token exchange work, and whether it all works cleanly in an Angular app or is React-only. This is where the platforms differ most for Angular teams: most ship framework-agnostic SDKs, but some reserve their official packages or pre-built UI for React and Vue. 3. **Depth on complex systems of record:** Salesforce, HubSpot, NetSuite, Workday, Zendesk, and the custom fields and schemas that come with them. The differences show up in custom fields and per-customer schemas rather than in standard objects. 4. **Catalog breadth:** how many APIs ship pre-built, and what happens when the one you need is missing. A large catalog only matters if there is also a documented path for the API it doesn't cover. 5. **Auth and credential handling:** where tokens are stored, how they refresh, and whether credentials ever touch the browser. 6. **Deployment and compliance basics:** SOC 2, GDPR, hosting regions, and self-hosting or BYOC (deploying in your own cloud). 7. **Pricing transparency:** public pricing versus "book a demo". Whether billing is per connection or usage-based also determines how costs grow with your customer base. 8. **Open source:** whether you can audit the platform and keep a path out of vendor lock-in. A self-host path means you can keep running even if the vendor's pricing or roadmap changes. ## The best SDKs and platforms for embedding third-party integrations in 2026 ### 1\. Nango **Overview** [Nango](https://nango.dev/?ref=angularspace.com) pairs a catalog of 900+ pre-built APIs with integration logic you keep in your own repository. The platform handles authentication, the connect UI, token refresh, and proxying; you write product-specific syncs, actions, and webhook handlers as functions. The core platform is [open source](https://github.com/NangoHQ/nango?ref=angularspace.com) and self-hostable. Nango's [building-nango-functions skill](https://nango.dev/docs/getting-started/coding-agent-setup?ref=angularspace.com#skills) lets Cursor, Codex, Claude Code, and other coding agents write those functions, test them with `nango dryrun` against a live connection, and deploy them. [Pricing](https://nango.dev/pricing?ref=angularspace.com) is public and usage-based with a free tier; metered charges include connections plus platform usage such as proxy requests and function compute. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/NangoAPIs.gif) **Best for** Engineering teams building deep, custom integrations that need a broad pre-built catalog while keeping their integration logic in code. **Pros** - **Pre-built catalog of 900+ APIs:** the [catalog](https://nango.dev/api-integrations?ref=angularspace.com) covers providers using API keys, basic auth, OAuth 2.0, OAuth 1.0a, and custom provider-specific schemes, with a drop-in connect UI and automatic token refresh. - **SDKs for frontend and backend:** the `@nangohq/frontend` SDK is framework-agnostic TypeScript that plugs directly into an Angular service, and the `@nangohq/node` backend SDK covers session tokens, proxy requests, and webhook verification. - **White-label connect UI:** the connect UI can run under your product's branding, and the headless `nango.auth()` path lets you keep your own design system entirely. - **Management MCP tools:** the [Management MCP server](https://nango.dev/docs/updates/changelog?ref=angularspace.com#new-management-mcp-tools) exposes 14 tools, so coding agents can configure integrations, inspect connections, call external APIs, and search the Nango docs directly. - **Deployment and compliance:** [SOC 2 Type II and GDPR compliance, with a HIPAA BAA on request](https://trust.nango.dev/?ref=angularspace.com), tenant isolation at scale, and an Enterprise option to run the full platform in your own cloud account and region, self-hosted or BYOC. - **Code-first development:** integrations live as functions in your repo, so engineers can implement custom fields, objects, and per-customer rules for systems like Salesforce or NetSuite directly in TypeScript. `nango dryrun` tests functions against real connections, the CLI can generate tests, and platform operations produce logs, with OpenTelemetry export of sync, action, webhook, and proxy executions on the plans that include it. **Cons** - **More upfront work than a fixed unified API:** the builder skill can generate a starting point, but your team still owns the data models and mappings. - **The free self-hosted edition is limited:** it targets lightweight deployments that need auth and the proxy, without functions, webhooks, or the platform's managed features; self-hosting the full platform requires an Enterprise plan. **Angular integration notes** `@nangohq/frontend` is plain TypeScript with no framework dependency. You can call it directly from an Angular service. Your backend mints a short-lived session token, the frontend opens the connect UI, and with the proxy or functions handling provider calls, OAuth access and refresh tokens do not need to enter the Angular app or your backend. The full worked example below uses it. ### 2\. Merge **Overview** [Merge](https://merge.dev/?ref=angularspace.com) normalizes 240+ integrations into common data models through category-specific unified APIs, including HRIS, ATS, accounting, CRM, ticketing, file storage, knowledge base, and chat. Your customers authenticate through Merge Link, and you consume one API per category. A separately sold Agent Handler product exposes its connectors to AI agents as MCP tools. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/69775512e7a6e71dbb938124_68e52c1b87224a9ceebdca7e_66bb079fbdbd949699c23e61_66bb062156980bdaa4b29477_merge.png) **Best for** Teams that need unified APIs with fixed data models, rather than custom object access in their APIs. **Pros** - **Fast category coverage:** one implementation gives you access to multiple providers through the category's common models, which are well established for HRIS and ATS. - **Embedded auth options:** Merge Link handles the connect UX, and a hosted [Magic Link](https://docs.merge.dev/merge-unified/merge-link/magic-link?ref=angularspace.com) variant needs no frontend code at all. - **Compliance and regional hosting:** [ISO 27001 and SOC 2 Type II certifications, plus HIPAA and GDPR](https://merge.dev/security?ref=angularspace.com), with US, EU, and APAC hosting options. **Cons** - **The common model constrains you:** field mapping, Remote Data, custom objects, and authenticated passthrough can cover some gaps, but access varies by feature and plan: all four require at least the contract-priced Professional plan, and programmatic field mapping is Enterprise-only. Passthrough requests still require provider-specific API calls. - **You cannot extend the unified API yourself:** there is no way to add an unsupported provider to Merge's unified APIs on your own. Agent Handler can [register a remote MCP server as a custom connector](https://docs.merge.dev/merge-agent-handler/build/connecting-agents/custom-mcp-servers?ref=angularspace.com), but you host and operate that server yourself. - **Faster syncs require higher plans:** the first three production linked accounts are free; the Launch plan then costs [$650 per month for up to 10 linked accounts, with additional accounts at $65 each](https://merge.dev/pricing?ref=angularspace.com), and syncs daily. Customizable sync frequency and additional customization features sit on the contract-priced Professional and Enterprise plans. **Angular integration notes** Merge ships official React and Vue packages, but no Angular one. From Angular you load their CDN script (`cdn.merge.dev/initialize.js`) and drive the global `MergeLink` object yourself: call `MergeLink.initialize` with a backend-created link token, open the modal with `MergeLink.openLink()`, then exchange the returned public token server-side. You must provide the TypeScript definitions and Angular lifecycle handling yourself. ### 3\. Paragon **Overview** [Paragon](https://www.useparagon.com/?ref=angularspace.com) uses a visual workflow engine for embedded integrations. You compose integrations from pre-built steps across 130+ connectors, embed the customizable Connect Portal for customer auth, and optionally express workflows in code through Paragraph, its TypeScript framework, which syncs back into the visual builder. For AI products, ActionKit gives agents 1,000+ pre-built actions. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/paragon-visual-workflow-builder.png) **Best for** Teams that would rather assemble integrations from pre-built workflow blocks than write them as code, with product or solutions engineers doing much of the building. **Pros** - **Embedded auth options:** the Connect Portal is customizable, and a headless mode lets you keep your own design system while Paragon handles auth. - **Pre-built tools for agents:** ActionKit includes a tool catalog, an MCP server, and triggers for agent tool calls. - **Flexible deployment:** cloud with US and EU regions, or self-hosted in your own AWS, Azure, or GCP account on the Enterprise plan, plus [HIPAA, GDPR, SOC 2 Type II, and ISO 27001](https://security.useparagon.com/?ref=angularspace.com). **Cons** - **Custom logic stays inside the workflow model:** code written with Paragraph still runs as a Paragon workflow, subject to plan-based workflow and concurrency limits, and its JavaScript Function steps are restricted to supported npm modules. - **Tight limits outside Enterprise:** function steps [cap at 1 minute of execution](https://docs.useparagon.com/workflows/functions?ref=angularspace.com) on Trial, Basic, and Pro plans, with [20 concurrent step executions](https://docs.useparagon.com/billing/concurrency-limits?ref=angularspace.com) on Pro. - **No public pricing:** no dollar figures are published; quotes are based partly on connected users. **Angular integration notes** `@useparagon/connect`, Paragon's frontend JavaScript SDK, works directly from Angular: sign a JWT for the user on your backend, call `paragon.authenticate(projectId, jwt)`, then `paragon.connect('salesforce')` to open the portal. Headless mode gives Angular teams full control over the connect UI. ### 4\. Prismatic **Overview** [Prismatic](https://prismatic.io/?ref=angularspace.com) supports two ways to build integrations: a low-code visual designer and code-native TypeScript projects built with its open-source Spectral library and `prism` CLI. It can also embed an integration marketplace and an end-user workflow builder in your product. The docs catalog lists 200+ built-in components, and connector source code is public. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/prismatic-1.jpg) **Best for** Teams needing a visual designer for non-engineers or end customers, plus a TypeScript option for engineers. **Pros** - **Embeddable marketplace and workflow builder:** end customers can browse, activate, and even build integrations inside your product. - **Broad deployment options:** [US, Europe, Canada, Sydney, Cape Town, AWS GovCloud](https://prismatic.io/docs/configure-prismatic/deployment-regions/?ref=angularspace.com), or a dedicated deployment in your own AWS account, with SOC 2 Type II plus HIPAA and GDPR. - **SDK for programmatic control:** the Spectral SDK and `prism` CLI let engineers provision the UI-based flows programmatically, with the option to add custom scripts where a pre-built component falls short. **Cons** - **Embedded screens use hosted iframes:** the default marketplace and workflow-builder embeds use hosted iframes. You can build a custom marketplace with the SDK, but the hosted screens offer less styling control. - **Runtime limits:** 15 minutes maximum execution per run and 1 GB of memory by default (raisable to 10 GB), with requests rejected (HTTP 429) once plan concurrency is hit ([runner limits](https://prismatic.io/docs/integrations/integration-runner-environment-limits/?ref=angularspace.com)). - **Syncs are flow-based rather than a normalized managed-sync API:** Prismatic supports large data syncs natively in code-native integrations and through batched custom triggers in the low-code designer and embedded workflow builder, alongside persisted cross-execution state and cursors. You still build the sync from flows and triggers rather than consume a sync API. Pricing is sales-led, with the embedded workflow builder starting at the Enterprise tier on the [pricing page](https://prismatic.io/pricing/?ref=angularspace.com). **Angular integration notes** `@prismatic-io/embedded` is framework-agnostic (npm or a UMD script tag). You authenticate with an RS256 JWT from your backend, then point `prismatic.showMarketplace({ selector: '#placeholder' })` at a DOM element in your component's template. Angular's view encapsulation does not reach into the iframe, so theming happens through Prismatic's config rather than your styles. ### 5\. Apideck **Overview** [Apideck](https://www.apideck.com/?ref=angularspace.com) is a unified API vendor that sends requests to providers in real time instead of syncing records into a vendor-side cache. It covers 200+ connectors across its unified API categories, including accounting, CRM, HRIS, e-commerce, ATS, file storage, and issue tracking. Customers authenticate through Vault, which ships as a hosted page or an embeddable modal. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/69ab8811ea53bf3977f2aecc_698d29b02d5bf88aac360057_66bb71495ea6629c48a32804_66bb7038f58fb1c4b6848e71_apideck.png) **Best for** Teams that want unified API coverage across several categories and prefer real-time requests over a vendor-managed record cache. **Pros** - **Public, self-serve pricing:** [pricing](https://www.apideck.com/pricing?ref=angularspace.com) is public and based on active consumers, with unlimited connections per consumer. - **Proxy on every plan:** raw passthrough requests to supported providers are available on every plan. - **Zero data retention for business data:** customer records and API payloads are not persisted. Encrypted OAuth credentials and optional log metadata are stored, and on-prem connectors like QuickBooks Desktop are a documented exception. **Cons** - **Uneven depth across categories:** as of August 2026, the [connector directory](https://www.apideck.com/integrations?ref=angularspace.com) lists five file storage and nine issue tracking connectors versus 53 for accounting and 59 for HRIS, so check that the providers and data models you need are available. - **No managed record cache or sync engine:** for workflows beyond real-time request-response calls, your team must store records and track sync state, though Apideck's native and virtual [webhooks](https://developers.apideck.com/guides/webhooks?ref=angularspace.com) help with change detection. - **Enterprise-only branding and SSO:** removing Apideck branding from Vault and SSO both require the Enterprise plan. **Angular integration notes** `@apideck/vault-js` is vanilla JavaScript and straightforward to use from Angular: create a session server-side with a `session_length` you choose (one hour by default, up to one week), then `ApideckVault.open({ token })` from any component. Callbacks such as `onConnectionChange` can update Angular signals directly. ### 6\. Pipedream Connect **Overview** [Pipedream Connect](https://pipedream.com/docs/connect?ref=angularspace.com) brings Pipedream's managed authentication, API proxy, and workflow tools into customer-facing products, with [10,000+ built-in API operations across 3,000+ APIs](https://pipedream.com/docs/connect/components?ref=angularspace.com). ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/69ab949e1f8dc889aaaee357_699756fde6b77da9c463530e_699753a8c1aacae60907e5cd_6995e85bca9ae3d90ccc7896_PipedreamConnectWorkflows.png) **Best for** Fast prototyping, internal automations, and long-tail APIs that may be missing from smaller catalogs. **Pros** - **3,000+ apps in the catalog:** the catalog spans more than 3,000 apps, and its components are source-available. - **Public, self-serve pricing:** development is free, and production billing is based on compute credits plus the number of unique external users ([pricing docs](https://pipedream.com/docs/pricing?ref=angularspace.com)). - **MCP support:** the same catalog powers an MCP server exposing thousands of tools. **Cons** - **Action configuration is multi-step:** unless you use `@pipedream/connect-react`, running a pre-built action means first retrieving and configuring its properties through a series of API calls, which adds frontend work to an embedded flow. - **No managed sync engine:** to build a sync, you combine [deployable pre-built triggers](https://pipedream.com/docs/connect/components/triggers?ref=angularspace.com), workflows, and your own storage. Custom tools can be published on the Business plan, but publishing your own custom triggers is [listed as coming soon](https://pipedream.com/docs/connect/components/custom-tools?ref=angularspace.com) as of August 2026\. Hard limits apply, such as a 30-second proxy timeout. - **No self-hosted Connect:** Pipedream does not document a self-hosted option for Connect; hosting is Pipedream's managed cloud on AWS in the us-east-1 region ([privacy and security docs](https://pipedream.com/docs/privacy-and-security?ref=angularspace.com)). **Angular integration notes** The core `@pipedream/sdk` runs in any browser app, so the token flow and the client's `connectAccount()` method work from Angular. But Pipedream's pre-built UI components for configuring actions ship only as `@pipedream/connect-react`. An Angular team either rebuilds those prop-configuration forms by hand or works with the core SDK directly. ## Worked example: adding a "Connect your CRM" flow to an Angular app For this example, let's use Nango's SDK to build the integrations page. The browser receives only a short-lived session token, which Nango expires after 30 minutes. Nango handles OAuth through its connect UI, while your server uses the connection ID for proxy calls or functions. Provider access and refresh tokens never need to enter the Angular app or your backend. Let's start with the backend. `server/integrations.ts` creates the Nango client and exposes an endpoint that mints a session token for the signed-in user. The client takes the webhook signing key up front, because the same file verifies webhooks further down: ```typescript import { Nango } from '@nangohq/node'; const nango = new Nango({ apiKey: process.env.NANGO_API_KEY!, webhookSigningKey: process.env.NANGO_WEBHOOK_SIGNING_KEY!, }); app.post('/api/integrations/session', async (req, res) => { const { data } = await nango.createConnectSession({ tags: { end_user_id: req.user.id, organization_id: req.user.orgId }, allowed_integrations: ['salesforce'], }); res.json({ sessionToken: data.token }); }); ``` The endpoint returns one thing: a session token scoped to this user and to the Salesforce integration. That token is all the frontend ever sees. Next, we create an Angular service for the connect flow and expose the connection state as a signal. `@nangohq/frontend` has no framework dependency, so no wrapper is needed. We use `fetch` here to keep the example small; in a real app you would call this endpoint through `HttpClient` so your auth interceptor covers it: ```typescript import { Injectable, signal } from '@angular/core'; import Nango from '@nangohq/frontend'; @Injectable({ providedIn: 'root' }) export class IntegrationsService { readonly crmStatus = signal<'disconnected' | 'connecting' | 'connected'>('disconnected'); async connectCrm(): Promise { this.crmStatus.set('connecting'); try { const res = await fetch('/api/integrations/session', { method: 'POST' }); if (!res.ok) throw new Error(`Session request failed: ${res.status}`); const { sessionToken } = await res.json(); new Nango().openConnectUI({ sessionToken, onEvent: (event) => { if (event.type === 'connect') this.crmStatus.set('connected'); if (event.type === 'error') this.crmStatus.set('disconnected'); if (event.type === 'close' && this.crmStatus() === 'connecting') this.crmStatus.set('disconnected'); }, }); } catch { this.crmStatus.set('disconnected'); } } } ``` The service requests a token, opens Connect UI, and tracks its events in the `crmStatus` signal. The `close` check resets the state if the user closes Connect UI before finishing. The provider's own OAuth page opens separately; pass `detectClosedAuthWindow: true` if you also want that popup's early closure treated as a failed authorization. Finally, the settings page component. Because the state is a signal, the `onEvent` callback updating it from outside Angular's control flow still renders correctly in a zoneless app: ```typescript import { Component, inject } from '@angular/core'; import { IntegrationsService } from './integrations.service'; @Component({ selector: 'app-integration-settings', template: ` @switch (integrations.crmStatus()) { @case ('connected') {

Salesforce is connected.

} @case ('connecting') {

Waiting for authorization...

} @default { } } `, }) export class IntegrationSettingsComponent { protected readonly integrations = inject(IntegrationsService); } ``` That is all the frontend code required for this example. Everything in it is standard modern Angular, and it runs unchanged on any currently supported version. After OAuth completes, Nango sends your backend a webhook containing the new connection ID. Configure a webhook URL and enable connection-creation webhooks in the environment settings first. Before using the payload, verify the `X-Nango-Hmac-Sha256` signature. Verification needs the raw request body, exactly as Nango sent it, so register this route with `express.raw()` before any global `express.json()` middleware. The `nango` client from the first snippet already has the signing key: ```typescript app.post('/api/webhooks/nango', express.raw({ type: 'application/json' }), (req, res) => { const rawBody = req.body.toString('utf8'); if (!nango.verifyIncomingWebhookRequest(rawBody, req.headers)) return res.sendStatus(401); const body = JSON.parse(rawBody); if (body.type === 'auth' && body.operation === 'creation' && body.success) { // Persist body.connectionId against the user in body.tags.end_user_id } res.sendStatus(200); }); ``` After that, your server can read CRM data through the proxy or run syncs for that connection ID. The [Nango quickstart](https://nango.dev/docs/getting-started/quickstart?ref=angularspace.com) is the shortest path to trying this flow yourself. The `connect` event in the UI is for optimistic state; the webhook is the source of truth. ![](https://storage.ghost.io/c/3f/63/3f6333b8-1f83-4017-8426-91bfbc264d81/content/images/2026/08/nango-connect-angular-settings-page.png) *Nango Connect UI opened from the Angular settings page using a short-lived session token.* ### The same flow on the other five platforms Each platform keeps provider credentials out of the Angular app, but the browser credential differs: some SDKs take a vendor-issued session or link token, while Paragon and Prismatic take a JWT your backend signs. What changes beyond that is the packaging, and how much UI you have to rebuild: | | Connect UI | Headless option | Your backend mints | Frontend packages | | ----------------- | ---------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------ | ---------------------------------------------------------- | | Nango | Connect UI (iframe modal); provider OAuth in a popup | Yes, via nango.auth() | Session token (30 min) | @nangohq/frontend, framework-agnostic | | Merge | Merge Link modal | No; hosted Magic Link covers the no-code case instead | Link token | React and Vue packages, CDN script otherwise | | Paragon | Connect Portal modal | Yes, headless Connect Portal | JWT you sign | @useparagon/connect, framework-agnostic | | Prismatic | Marketplace and workflow-builder iframes | Partial: custom marketplace UI over its API | RS256 JWT you sign | @prismatic-io/embedded, framework-agnostic | | Apideck | Vault modal | Partial: build your own UI on the Vault API | Vault session token (1 hour default) | @apideck/vault-js, vanilla JS, plus React and Vue wrappers | | Pipedream Connect | Pipedream iframe; provider OAuth in a popup | Partial: you control the surrounding UI, but auth uses Pipedream's iframe | Connect token (4 hours) | @pipedream/sdk core; action-config UI is React-only | Two mechanics matter in an Angular app regardless of vendor. The first is popup blockers: browsers only allow `window.open` inside a user-gesture call stack. The modal and iframe SDKs sidestep this, because the provider's authorization popup opens from the user's click inside the vendor's surface, not from your code. A headless call such as `nango.auth()` opens the popup from your call stack instead, so awaiting a token request between the click and the SDK call can get the popup blocked in stricter browsers. In that case, mint the token when the settings page loads and call the SDK synchronously from the click handler. Nango surfaces this failure as a typed `blocked_by_browser` error you can react to. The second is server-side rendering. These frontend connection flows use browser APIs, so in an Angular SSR app, construct and call them from event handlers, as the service above does, or behind `afterNextRender`. ## Comparison of embedded integration platforms Use the table as an embedded iPaaS comparison at a glance; the two unified API vendors are included for contrast. | | Nango | Merge | Paragon | Prismatic | Apideck | Pipedream Connect | | ------------------------- | -------------------------------------------- | ----------------------------------- | ----------------------------- | ---------------------------- | ---------------------------------------------------------------- | -------------------------- | | Model | Code-first platform | Unified API | Low-code iPaaS | Low-code + code iPaaS | Unified API (real-time) | Embedded workflows | | Catalog | 900+ APIs | 240+ integrations | 130+ connectors | 200+ components | 200+ connectors | 3,000+ apps | | Angular-friendly SDK | Yes (plain TS) | CDN script only | Yes (plain JS) | Yes (iframe-based) | Yes (plain JS) | Partial (UI is React-only) | | Custom integration logic | Full (code) | Mapping, remote data, passthrough | Workflows + custom connectors | Code-native TS | Proxy only | Actions, workflows, proxy | | Custom fields and objects | Full, in code | Plan-gated, limited | Via workflows | Via code | Field Mapping (Scale+); CRM custom objects (connector-dependent) | Via raw API | | Data syncs | Native, incremental | Managed (daily on entry plan) | Managed Sync (1-min default) | Flows + large data syncs | None (real-time) | Triggers + workflows | | Pricing | Public, free tier | Entry public, then sales-led | Sales-led | Sales-led | Public | Public | | Self-host or own-cloud | Self-host or BYOC (Enterprise; limited free) | Available for purchase (Enterprise) | Yes (Enterprise) | Own AWS account (Enterprise) | No | No | | Open source | Core platform (ELv2) | Proprietary | Proprietary | Connectors public | Proprietary | Components public | The catalog totals come from each vendor's site in August 2026 and are not directly comparable, because vendors count APIs, connectors, and components differently. "Angular-friendly SDK" means an official framework-agnostic path you can call from Angular, whether the package ships as TypeScript or plain JavaScript. "Open source" identifies which part of the stack is public, not merely whether a client SDK is available. "Custom integration logic" distinguishes code you control from provider-specific passthrough or proxy calls. ## FAQ ### How do I add email sync to my SaaS product without building IMAP infrastructure? Use an embedded integration platform that manages Gmail and Microsoft Graph for you; those two APIs cover Google Workspace and Microsoft 365 mailboxes with no IMAP involved. Most of the work lies in OAuth token refresh, Gmail's Pub/Sub `watch` renewals, Graph subscription lifecycles, and sync state rather than the API calls themselves. Nango, for example, handles auth and runs the sync as code you control. ### What are the best embedded integration platforms for B2B SaaS products enabling customer self-service connector setup? All six platforms here support self-service setup, where end users link their own accounts from your UI. What varies is how much of the interface you can brand and how much configuration customers can manage themselves. Nango's connect UI and Paragon's Connect Portal both offer headless modes, and Prismatic embeds a whole self-service marketplace. Merge's white-label and Link customization features sit on its Enterprise plan, and Apideck requires its Enterprise plan to remove Vault branding. If customers must also configure field mappings or other integration settings, check whether they do that through your code, a visual builder, or the platform's UI. ### Which embedded integration platforms have a visual flow designer and pre-built connectors? Paragon, Prismatic, and Pipedream pair pre-built connectors with a visual flow designer; Prismatic also lets you embed the designer for end customers. Before choosing one, confirm that its step, runtime, and concurrency limits can handle your syncs and provider-specific logic. ### What are the highest rated embedded integration platforms for connecting customer tools? There is no stable independent rating for this category. Based on the criteria above, Nango fits engineering teams building deep, custom integrations. Merge fits teams that need unified APIs with fixed data models, while Paragon fits non-technical teams that want low-code workflows. All six platforms let customers connect their own tools from inside your product. ## Conclusion Integration requirements rarely stay simple. One customer may depend on dozens of custom Salesforce fields, while another needs an API the platform does not cover. Once requests like these arrive, catalog depth and control over the integration logic matter more than how quickly the first demo came together. For teams building deep, custom integrations, Nango is the strongest option in this comparison. Its catalog spans more than 900 APIs, the integration logic remains in code, and teams can choose Nango Cloud, self-hosting, or BYOC on an Enterprise plan. Merge is a better fit for teams that need unified APIs with fixed data models rather than custom object access, while Paragon and Prismatic suit teams that prefer a visual approach. Whatever platform you choose, keep provider credentials out of the browser. The frontend should receive only a short-lived token, while the code that reads and transforms customer data stays under your team’s control.