# Headless API — Build your own integration UI on top of Albato's API Source: https://albato.com/headless-api 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](https://albato.com/en/wiki/embedded-api-methods) 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 Diagram of Albato's headless API integration model with a custom frontend 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. Mock interface listing automation templates with Mailchimp, Google Sheets and HubSpot rows, each with a toggle switch ### 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 UX browser icon ### 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. Branching connection icon ### 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. Tools and settings icon ### 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 $3,000/month. Data migration between systems icon ### 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 Window icon representing the iFrame integration modeliFrame Model Code brackets icon representing the Headless API modelHeadless 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 Connector access1,000+ apps Backend maintenance Backend maintenanceAlbato 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 Weeztix Logo[Case study→](https://albato.com/blog/publications/embedded-weeztix-case) Sendr Logo RD Station Logo[Case study→](https://albato.com/blog/publications/rd-station-case) Voicedrop AI Logo Chatfuel Logo[Case study→](https://albato.com/blog/publications/embedded-chatfuel-case) Maestra Logo[Case study→](https://albato.com/blog/publications/maestra-case) Vivantio Logo Mobilo Logo Knack Logo Copilot AI Logo Duda Logo Bitrix24 Logo Feefo Logo Weeztix Logo[Case study→](https://albato.com/blog/publications/embedded-weeztix-case) Sendr Logo RD Station Logo[Case study→](https://albato.com/blog/publications/rd-station-case) Voicedrop AI Logo Chatfuel Logo[Case study→](https://albato.com/blog/publications/embedded-chatfuel-case) Maestra Logo[Case study→](https://albato.com/blog/publications/maestra-case) Vivantio Logo Mobilo Logo Knack Logo Copilot AI Logo Duda Logo Bitrix24 Logo Feefo Logo Alex Gornik, CEO at Maestra 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? collapsed 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? collapsed 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? collapsed 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? collapsed 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? collapsed 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? collapsed 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? collapsed iFrame is available from $3,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](https://albato.com/en/wiki/embedded-api-methods)