Beta — Early Access

Build your own integration UI
on top of Albato's API

Albato exposes 11 REST endpoints for managing users, connections, billing, and integration
metadata across 1,000+ connectors. You can call the Albato AI to manage your entire integration layer on autopilot.

Read the docs

1,000+app connectors

11REST API methods

Fullbackend managed by Albato

The same API, without the prebuilt UI

Albato Embedded has 2 primary integration models. iFrame gives you an out-of-the-box integration UI you can embed into your product. Headless gives you the same integration capabilities, but you access them via API and build your own frontend on top.

iFrame model

Embedded a ready-to-use UI

Diagram of Albato's iFrame integration model embedded into a product

Plug Albato's white-labeled automation builder into your product as an iFrame. The fastest path to go live with minimal dev work.

Best for: Teams that want integrations live in days with near-zero dev effort.

Headless API

Integration backend via API + your own UI

Use Albato's APIs to programmatically manage users, connections, and billing. Integration specs and metadata come as JSON — fully customizable on your frontend.

Best for: Engineering teams that need full control over the integration UX.

3 layers. You own the top one.

Albato handles connectors and data orchestration. The Embedded API provides you with 11 endpoints to manage the embedded platform. You build the UI layer on top.

Three stacked integration layers: Your layer on top, Embedded API layer in the middle, Albato layer at the bottom

The UI is built by your team

The Albato API returns data from any of 1,000 apps' endpoints, and it's up to you how to render it in your UI. Use your own component library, follow your own UX patterns, and ship it as part of your product. There's no Albato UI involved.

11 endpoints for integration operations

User access provisioning, connection management, metadata retrieval, and billing. The same methods are also available in the iFrame model, exposed as REST endpoints with JSON responses.

User provisioning
Session tokens
SSO connections
Billing & plans
Connection metadata

1,000+ connectors, maintained by Albato

Albato handles connector auth flows, data exchange, and API versioning for 1,000+ apps. When a third-party API changes, Albato updates the connector. Your team doesn't touch it.

Modular by design

Use the Universal API to call a single third-party endpoint or a Solution API to invoke a prebuilt automation scenario. The endpoints are independent, so you pick what you need.

Custom Integration Marketplace

Pull the Albato connector catalog through the API, categorize it by use case, and build a branded app marketplace inside your product. Your customers browse and enable connectors without leaving your UI.

One-Click Automation Templates

Package common workflows as pre-configured solutions (CRM sync, lead routing, e-commerce automation). Customers toggle them on with a single click.

Custom Connection Flows

Build an OAuth and connection UX that match your product's look and feel. Albato's white-label OAuth flow handles the token management from A to Z while your UI stays consistent.

Custom Automation Builder

Retrieve specific integration endpoints from the Albato API and map them to your own workflow builder. Build a full-fledged automation experience that's part of your product, not a third-party embed.

Mock interface of an automation builder with a Shopify trigger card connected to a Gmail action card

When the iFrame doesn't fit

Full control over the integration UX

No iFrame UI constraints. The integration screens use your component library and follow your UX patterns. Customers can't tell where your product ends and Albato's integrations begin.

Place integrations anywhere in your app

Trigger oAuth connections during customer onboarding, show integration status in your native dashboards, embed integration buttons throughout your platform. The Albato API doesn't care where you call it from.

Custom frontend, managed infrastructure

You're building a smooth UI, not rebuilding integration infrastructure. Albato handles connectors, auth, data mapping, error handling, and API updates for 1,000+ apps. For comparison: building integration backend infra and handling logic in-house typically costs around $200,000 and takes 4-7 months before ongoing maintenance. Headless starts at $5,000/month.

Start with iFrame, migrate to headless

Most teams launch with the iFrame to go live in 30-45 days, then move core integrations to headless as their needs evolve. It's a seamless transition for your users and a much easier process for your team.

Side-by-side comparison

Feature

iFrame Model

Headless API

UI ownership

UI ownershipAlbato (white-labeled)

UI ownershipYou (fully custom)

Frontend dev effort

Frontend dev effortNear zero

Frontend dev effortModerate to high

Time to production

Time to production30-45 days

Time to productionDepends on UI scope

Brand control

Brand controlHigh (customizable)

Brand controlTotal (you build it)

Connector access

Connector access1,000+ apps

Backend maintenance

Backend maintenanceAlbato

Best for

Best forFast launch, lean teams

Best forUX-driven products, strong eng teams

Albato also offers other integration models (including Connection via Link API). iFrame and headless are the most common. Both share the same API, connectors, and billing, and can run in parallel.

Teams running on Albato's infrastructure

These companies use Albato Embedded for native integrations, via iFrame, headless, or both.

250K+end users across partner platforms

250M+monthly transactions processed

4.6/5G2 rating

Albato helped us build it in 1-2 months, with almost zero engagement from our R&D.

Alex Gornik, CEO at Maestra

Common questions from engineering teams

Is the Headless API a separate product from Albato Embedded?

No. Same platform, same API, same connectors. The difference is whether Albato's iFrame renders the integration UI or your frontend does. You can benefit from both models at the same time.

Do we need to build our own backend for integrations?

No. Albato handles connectors, auth, data orchestration, error handling, and API maintenance. You only build the frontend if you want.

What API methods are available in headless mode?

11 methods to manage the embedded integration logic: user management, billing, connections, and metadata. Plus thousands of endpoints across third-party apps (triggers & actions). In headless mode you call them directly and render the responses yourself.

How long does a headless implementation take?

Depends on the UI scope. The iFrame path takes 30-45 days. Headless adds time proportional to building your custom frontend. Many teams start with iFrame and migrate key integrations to headless down the road.

Can we use iFrame for some flows and headless for others?

Absolutely. Both run on the same API and work in parallel. You could use the iFrame for the embedded automation builder while building custom headless flows for more complex integrations that require greater UX flexibility.

Who maintains the connectors when third-party APIs change?

Albato. Ongoing connector maintenance is on us regardless of whether you use iFrame or headless. When an API updates, Albato pushes the fix.

What's the pricing difference between iFrame and headless?

iFrame is available from $5,000 per month, while headless is included in the Pro plan starting at $5,000 per month.

Let's scope your headless implementation

We'll walk through your architecture, recommend where iFrame vs headless makes sense, and outline a realistic timeline.

Read the API docs

Build your own integration UI on top of Albato's API