The embedded iPaaS market in 2024 includes over 30 vendors that provide an embedded iPaaS (embedded integration platform).
With so many different embedded iPaaS solutions, how do you find the best embedded iPaaS to help you build and manage integrations to your customers' other apps?
Based on our experience working with many B2B SaaS companies on their integration projects, we recommend five factors for evaluating embedded iPaaS solutions.
6 factors for evaluating embedded iPaaS solutions
- Is the vendor's focus on embedded iPaaS? Or is the embedded iPaaS just one of several products it has brought to market?
- Does the platform support a good dev experience? Does it have an API and CLI that lets you write entire integrations in code and work with existing tools and processes? Does it have comprehensive docs?
- Does the platform support non-devs well? Can they assemble simple integrations with the low-code builder? Are they able to onboard customers without engineering help? Does the platform provide them with everything they need to troubleshoot and fix straightforward issues with deployed integrations?
- Can you build the specific integrations you need? In addition to a low-code designer and API connectors, does the platform handle complex integrations and allow you to code robust custom connectors?
- Does the platform allow you to deploy and manage integrations at scale? Is its infrastructure scalable? Does it enable non-devs to troubleshoot and support integrations?
- Does the platform provide a great user experience for your customers? Can they configure, activate, and troubleshoot their own integrations? Can they use an embedded workflow designer to build their own integrations with your product? Can they integrate with non-SaaS apps running in their local networks?
Let's look at several popular embedded iPaaS solutions and see how they stack up.
Prismatic
We'll start with our own. You won't be surprised that it's a spot-on solution for most B2B SaaS teams. But we strongly encourage you not to take our word for it. Check out customer reviews and compare our product to other solutions on G2.
Focus: Since its founding, Prismatic has focused solely on the embedded iPaaS market. Its embedded integration platform was built from scratch for B2B SaaS companies that need to create native integrations to their customers' other apps.
Dev Experience: You can access a development API and CLI, and the platform plays nicely with existing processes for versioning and managing integration code. Prismatic includes a fully integrated dev environment that can be used to write and deploy custom TypeScript code as part of your integrations. Its approach to coding custom components is second to none. For complete flexibility, you can use our code-native experience to write integrations entirely in code in your preferred IDE.
Non-Dev Experience: Prismatic has a low-code designer with a library of API connectors and other pre-built components to enable integration functionality. In addition, the platform enables non-devs to deploy, configure, activate, and support integrations. This includes a customer-management UI that provides comprehensive access to logging and alert data for your customers and their integrations.
Specific Integrations: Prismatic provides users with a lot of flexibility to build both simple and complex integrations as well as those connecting to vertical-specific apps. Its code-native integration experience offers maximum versatility for handling messy, real-world integration scenarios.
Deploy and Manage: Prismatic supports building configurable integrations that you can deploy to many different customers. Its management environment is more comprehensive than most and gives non-devs a full view of customers' integrations and tools like logging to support them.
User Experience: Prismatic's embedded integration marketplace allows your customers to self-activate, configure, monitor, and troubleshoot their integrations without leaving your app. It also includes an embedded designer enabling customers to build their own integrations from within your product. And, with our on-prem agent, you can build integrations between your product and whatever apps your customers are running on their local private networks.
Tray.io
Focus: Tray.io was founded in 2012 as an enterprise iPaaS, enabling business users to automate internal workflows. This product remains Tray's primary focus today. The company introduced Tray Embedded in 2020 by adding features to its existing enterprise iPaaS. Tray Embedded seems to be losing its early market traction, and users report it contains many "workarounds" due to its origins as an enterprise iPaaS.
Recently, Tray switched to offering its embedded iPaaS as an add-on bundle for its Enterprise iPaaS package. Customers now need to purchase both the enterprise iPaaS and embedded iPaaS if they only need the embedded iPaaS.
Dev Experience: Tray Embedded does not have a CLI, and while it does have an API, only a subset of its functionality is available. Devs report difficulty understanding which parts of Tray's docs apply to its enterprise iPaaS, embedded iPaaS, or both. In addition, Tray does not support devs who need to write integrations in code (that is, there is no code-native option).
Non-Dev Experience: Tray offers a large library of app connectors and a drag-and-drop integration designer, enabling non-dev teams to build integrations to hundreds of common apps and define the configurations for those apps. In addition, non-devs can access logs and analytics for deployed integrations.
Specific Integrations: Tray doesn't fare as well with non-standard integrations that don't use standard off-the-shelf connectors. The platform allows you to generate HTTP-only low-code custom connectors but not to code full-fledged custom connectors or include your own code in integrations.
Deploy and Manage: Tray is missing some key capabilities for managing customers' integrations at scale. For example, it does not have granular versioning control of integrations and their connectors, making it difficult to roll out an updated version of an integration across your customer base. You can, however, view logs on the platform or stream them to a third party.
User Experience: Tray provides an integration marketplace that can be embedded within your SaaS product and a config wizard to drive the customer experience for setting up integrations. Your customers can also perform data mapping for integrations. However, Tray does not enable your customers to build their own integrations or offer self-service support tools such as logging and alerting.
Workato
Dev Experience: Workato offers an SDK for building custom connectors but is limited to a white-listed subset of Ruby. Its sales and onboarding processes tend to be heavy for developers, who must contact sales to start a trial and go through a slow implementation. Also, Workato does not provide devs with a means of building code-native integrations (writing integrations entirely in code).
Non-Dev Experience: Workato provides a high-quality low-code designer and over 1,000 application connectors. These make it straightforward for non-devs to assemble simple integrations. Non-devs can also use the admin console to manage and monitor customers and integrations, and access usage metrics.
Specific Integrations: While its custom component SDK could be more dev-friendly, it does allow building custom components. Overall, Workato lets you build a wide variety of integrations, from simple to advanced.
Deploy and Manage: Workato allows for the entire platform to be embedded in your SaaS product rather than embedding just the marketplace or the integrations. As a result, your customers can see everything (connectors, builders, and recipes) that your teams work with. In addition, you can view logs in the platform or stream them to a third-party.
User Experience: Workato's embedded offering has been used as the foundation for relatively large-scale integration marketplaces. Large or sophisticated customers can design and build their own integrations.
Paragon
Focus: Since shortly after it started, Paragon has focused on the B2B SaaS integration market. Many of its customers are B2B SaaS startups that need a handful of integrations to common apps.
Dev Experience: Paragon provides functionality for building custom connectors to REST APIs, though you need to use the low-code builder, and options for creating a custom connector are limited. Paragon recently released Paragraph, a framework for building integrations in code, but the code you write must conform to the constraints of the low-code builder (so you can't actually write whatever you want to). And, while the framework is based on TypeScript, it is an implementation of a subset of TypeScript, so it does not simply support whatever TypeScript you'd like to use. In addition, Paragon only allows for specific npm packages to be used in the code instead of allowing you to include whatever external packages and libraries you might want.
Non-Dev Experience: Paragon has a small but growing number of connectors to common SaaS apps. Non-devs can easily combine these connectors with the low-code designer to create simple integrations. Non-devs can also deploy and maintain integrations via the platform, including troubleshooting, usage tracking, and integration statuses.
Specific Integrations: In addition to the functionality provided by the pre-built connectors, Paragon allows your devs to build lightweight connectors to public APIs. However, it tends to fall short when it comes to complex or industry-specific integrations that follow non-standard patterns.
Deploy and Manage: Paragon provides an integration marketplace that lets your teams display both Paragon integrations and custom in-house integrations. Logs can also be viewed within the UI or streamed to third-party platforms.
User Experience: Your customers can select and activate integrations listed in the marketplace, filling out user credentials, field mappings, and other config options. Paragon does not offer an embedded integration builder.
Cyclr
Focus: Cyclr began as a general-purpose integration and automation product but quickly pivoted to be an embedded iPaaS. Since then, the company has primarily focused on the embedded iPaaS market. It also rolled out ConnectorEngine.com to sell a version of Cyclr that is built for the marketing services segment.
Dev Experience: Cyclr offers many connectors (and will build additional connectors), but it expects your teams to create everything with no-code/low-code tools. It does not allow you to write detailed code and otherwise interact with the platform via a development API or CLI.
Non-Dev Experience: The low-code builder is the core of what Cyclr provides. As a result, it is very easy for non-devs to visually assemble integrations from existing connectors and other tools. Non-devs can also use the management console to view usage, error, and other data about customers and integrations.
Specific Integrations: Cyclr relies heavily on its 400+ connectors for integrations. It abstracts/automates things such as auth, paging, and monitoring for those connectors. It also provides a low-code process for you to convert endpoints for a new API into a basic API connector.
Deploy and Manage: Deployments are performed through the embedded marketplace. Cyclr includes a console for you to manage the marketplace and integrations.
User Experience: Cyclr includes an embedded, white-labeled marketplace. Your customers can self-activate integrations but do not have logging or alerting tools to keep them current with integration statuses.
Frequently asked questions about embedded iPaaS
Question: What's the difference between an embedded iPaaS and an enterprise iPaaS?
Answer: An embedded iPaaS is a purpose-built platform software companies use to create native product integrations for their customers. An enterprise iPaaS is a general-purpose platform used by businesses to create integrations for internal use.
Question: What's the difference between an embedded iPaaS and a unified API?
Answer: An embedded iPaaS is a set of tools that enables a software company to quickly build reusable, configurable integrations to any app in any software category and deliver them to its customers as a seamless part of its app. A unified API, on the other hand, connects several APIs in a common, typically horizontal, software category, such as HRIS, to a single API to simplify the integration process.
Question: Is there a recommended process for choosing an embedded iPaaS?
Answer: Yes. 1) involve the right stakeholders; 2) confirm that the solution meets your high-level requirements; 3) get a demo; 4) perform a realistic POC; 5) verify the solutions' ability to handle real-world complexity; 6) confirm the platform's extensibility and custom connector support; and 7) ensure that the solution fits your tools and processes. For more details, check out our post on How to Choose an Embedded iPaaS for Your SaaS.
Question: Where can I learn more about embedded iPaaS?
Answer: Our What is Embedded iPaaS post is an excellent place to start.
How do I get independent comparisons of embedded iPaaS solutions?
G2 is a trusted business software review site with over 2.6 million verified user reviews that help buyers compare solutions and find the best fit for them. G2's quarterly Grid® Reports identify top products in each software category based on which products have the most satisfied customers and largest market presence.
To help determine the best embedded iPaaS for your needs, view all the embedded iPaaS solutions in G2's Embedded Integration Platform category or download G2's latest Grid® Report for Embedded Integration Platforms for an in-depth look at top-rated solutions.
There's nothing like working with the platform
Our analysis is no substitute for seeing those platforms in action. Once you've created a short list of embedded iPaaS solutions that best meet your requirements, it's time to set up some demos.
During the demos, check any assumptions you've made with each vendor and ask the hard questions. If you have specific use cases you are concerned with, bring them up in the demos and see how the vendors handle them. In short, use the demos to fill gaps in your understanding of each embedded iPaaS.
Then, for those systems that made it through your demo process, set up POCs. They will be critical to prove that the solutions you're considering can support your types of integrations. For example, a demo showing straightforward automation between two common SaaS apps does not prove that the platform can support a complex integration between your product and a niche third-party app with no built-in app connector. During each POC, build one or more typical integrations, maybe even the next integration in your backlog.
While we are discussing demos and POCs, schedule a demo if you'd like to see Prismatic's embedded iPaaS in action. We'll provide one tailored to your specific integration goals and pain points. Then, we can help you set up a POC that allows you to fully explore the tools and options we provide for building real-world integrations.
