[Articles](https://zato.io/articles/index.html)
# Open-Source Boomi Alternative (in Python)
**Boomi customers report price increases of 50 to 100 percent at renewal since the 2025 pricing changes, on a model in which every new connection, runtime and environment adds to the bill, while still leaving the developers to drag and drop dozens of shapes to achieve what ten lines of Python code would do.
This article shows how Boomi processes become Python code on an open-source platform that is not metered, and where adding an integration adds no licenses.**
By Dariusz Suchojad
11 min. read
Share this article: [LinkedIn](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fzato.io%2Farticles%2Fopen-source-boomi-alternative.html) | [FB](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fzato.io%2Farticles%2Fopen-source-boomi-alternative.html) | [Email](mailto:?subject=Open-Source Boomi Alternative article from zato.io&body=https://zato.io/articles/open-source-boomi-alternative.html)
- - -
## Connection licensing and Boomi Messages {#connection-licensing-and-boomi-messages}
Boomi subscriptions are sold in [editions](https://help.boomi.com/docs/Atomsphere/Integration/Getting%20started/c-atm-AtomSphere_Editions_bde0b272-5d32-46ec-82ea-6f9ffe98bd63) - Base, Professional, Professional Plus, Enterprise and Enterprise Plus - which differ in the number of included connectors, and features such as parallel processing, message queuing, runtime clusters and enterprise connectors are add-ons in the lower editions.
The connectors are [licensed per connection](https://help.boomi.com/docs/Atomsphere/Platform/c-atm-License_management_7f3b0031-d80a-49a4-a744-e8878108cd38). Each unique connection component deployed to a runtime consumes one license, so the same connection deployed to two runtimes in one environment consumes two, and a copy of a connection with a new component ID counts as a separate connection. A deployment that exceeds the purchased licenses does not complete. Production and test environments draw on [separate pools of licenses](https://help.boomi.com/docs/Atomsphere/Platform/c-atm-Test_connection_licensing_04708d54-8ea3-453f-8dac-3e2e6b72330b), and processes running on Boomi public runtime clouds are additionally metered by data volume.
The [Pay-As-You-Go plan](https://help.boomi.com/docs/Atomsphere/Platform/atm-Boomi_Pay_As_You_Go_d9f80432-a9de-4717-a7cf-4c9e3ea786c5) meters usage instead. It costs 99 USD a month plus 0.05 USD for each Boomi Message, and a Boomi Message is every inbound and outbound document of a process, regardless of its format or transport, including the responses of request and response interactions. Test and production messages are counted the same way, and existing subscription accounts [cannot be migrated](https://help.boomi.com/docs/Atomsphere/Platform/atm-Boomi_Pay_As_You_Go_FAQ_88ebfd22-b959-43ee-828b-0c4f99a5a8ef) to the plan.
Vendors that migrate Boomi customers report the effect at renewal. Celigo states that the [2025 pricing changes](https://www.celigo.com/blog/celigo-vs-boomi/), which introduced connector capacity and message caps, led to price increases of 50 to 100 percent at renewal in some cases, and Workato quotes former Boomi customers on [prices that rose by 50 percent in 18 months](https://www.workato.com/insights/workato-vs-boomi).
In both models, architectural decisions become license decisions. A second runtime for high availability, a new test environment, a process split in two or a trading partner that sends many small documents each change the license count or the monthly invoice.
Zato is not metered. There are no licenses per connection, per runtime, per environment or per message, so new environments and new integrations are added as the architecture requires.
## From drag-and-drop to Python {#from-drag-and-drop-to-python}
[](https://zato.io/docs/arch/index.html)
A Boomi process is built on the [process canvas](https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/c-atm-Process_canvas_7092acce-da3a-4bf1-9130-ac2b74eebd22) from steps that are dragged onto it and connected with arrows, up to 250 steps per process. Connector steps read and write data, [logic steps](https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/r-atm-Logic_shapes_7a64683e-8ddc-4606-97b4-497867883094) such as Decision, Branch, Route and Try/Catch direct the documents, and in [Map components](https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/c-atm-Map_components_87f669d6-4999-445f-9f29-ed24e79c92dd) the fields of a source profile are linked to the fields of a destination profile by drag and drop.
Logic that the steps do not express is written as [custom scripts](https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/c-atm-Custom_scripting_35340a9d-a236-403a-9f53-1563fceb61a5) in JavaScript or in Groovy, in versions 2.4.13 and 1.5.8. Boomi describes the custom scripting step as a [last resort](https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/c-atm-Custom_scripting_step_e28a6812-1cf6-4c0b-a623-224f09543c5e) - a script reads and writes the raw document streams, it cannot reference connections, profiles or maps, and ExecutionUtil is the only supported scripting API.
The logic of one integration is therefore spread across the shapes on the canvas, the property panels of each step, profiles, maps, map functions and scripts, all stored as components of the Boomi account and edited in the browser. A canvas makes the first integrations easy to draw and every later change harder to find, review and repeat. Drag-and-drop designers of this kind belong to an earlier generation of integration software.
In Zato, an integration is a Python service. Python is the most widely used programming language - first in the [TIOBE index](https://www.tiobe.com/tiobe-index/) for October 2026, and used extensively by 58 percent of the developers who answered the [2026 Stack Overflow Developer Survey](https://survey.stackoverflow.co/2026/technology/data/languages-timeseries). Python is also the contemporary language of data, machine learning and AI agents, the next generation of integration.
An integration in Python is one file that any Python developer reads, reviewed like any other code, versioned in Git and written fluently by AI assistants. It is developed in the IDE of your choice and tested with the [built-in testing framework](https://zato.io/docs/api-testing/index.html). Channels, connections and security definitions are configured in the Dashboard, which also shows the audit log of every message that the integrations process.
[](https://zato.io/docs/admin/audit-log/index.html)
## Boomi concepts and their Zato counterparts {#boomi-concepts-and-their-zato-counterparts}
| Boomi | Zato |
| --- | --- |
| Process | Python service |
| Decision, Branch and Route steps | Python |
| Map component and map functions | Python, with [data models and mappers](https://zato.io/docs/dev/rest/data-mapping.html) |
| Profile | [Data model](https://zato.io/docs/dev/model/index.html) |
| Groovy and JavaScript scripts | Python |
| Web Services Server connector and API Service component | Channels for [REST](https://zato.io/docs/dev/rest/channels.html) and [SOAP](https://zato.io/docs/dev/soap/index.html) |
| Database connector | [SQL connections](https://zato.io/docs/dev/examples/sql/index.html) |
| Atom Queue and Event Streams | [Built-in topics and queues](https://zato.io/docs/dev/message-queues/index.html) |
| Process schedules | [Scheduler](https://zato.io/docs/dev/examples/scheduler.html) |
| B2B/EDI Management with EDIFACT documents | [EDIFACT](https://zato.io/tutorials/edifact.html) interchanges parsed, routed and serialized in Python |
| API Management | [API management](https://zato.io/docs/api-management/index.html) |
| Business Rules step | [Rule engine](https://zato.io/docs/rule-engine/index.html) |
| Packaged components and deployments | GitOps, with the configuration of each environment in Git, and [hot deployment](https://zato.io/docs/dev/hot-deploy.html) of Python files |
| Process Reporting | Dashboard |
EDIFACT messages from trading partners, such as ORDERS, DESADV and INVOIC, are parsed into Python objects, routed by message type and serialized back byte for byte, in the same services that call the ERP, the databases and the REST APIs of the organization.
## A Boomi process rewritten in Python {#a-boomi-process-rewritten-in-python}
A typical Boomi process receives a shipment request, queries the ERP for the order, uses a Decision step on the order status, maps the shipment in a Map component to the booking format of the carrier and sends the booking to the carrier API. In Boomi, this process consists of a Web Services Server start step, connector steps for the ERP and the carrier with their connection and operation components, a Decision step, a Map component, a profile for each message format and a Return Documents step.
In Zato, the same service is one Python file:
```python
# -*- coding: utf-8 -*-
# stdlib
from dataclasses import dataclass
# Zato
from zato.server.service import Model, Service
@dataclass(init=False)
class Shipment(Model):
order_id: str
warehouse: str
carrier_service: str
weight_kg: float
class BookShipment(Service):
""" Books shipments with the carrier once the ERP confirms the order.
"""
name = 'shipping.book-shipment'
input = Shipment
def handle(self) -> 'None':
shipment = self.request.input
# The ERP confirms the order before the carrier is booked ..
params = {'order_id': shipment.order_id}
order = self.rest['ERP'].get(params=params)
if order.data['status'] != 'CONFIRMED':
self.response.payload = {
'is_booked': False,
'order_status': order.data['status'],
}
return
# .. the shipment becomes a booking request of the carrier ..
booking = {
'reference': shipment.order_id,
'origin': shipment.warehouse,
'service': shipment.carrier_service,
'weight': shipment.weight_kg,
}
response = self.rest['Carrier'].post(booking)
# .. and the caller receives the tracking number.
self.response.payload = {
'is_booked': True,
'tracking_number': response.data['tracking_number'],
}
```
The [tutorial](https://zato.io/tutorials/main/01.html) builds a complete integration of this kind, from an empty environment to a working API.
[](https://zato.io/docs/dev/rest/channels.html)
## Runtime and platform releases {#runtime-and-platform-releases}
Boomi states that [runtime and platform updates are not optional](https://help.boomi.com/docs/Atomsphere/Platform/atm-Runtime_and_Atomsphere_releases_8aa6b48e-b0b6-4382-8ffa-a7cf23f0314f). Each runtime release becomes available about two weeks before the platform release, and a runtime on which the release was not applied is updated automatically on the platform release date. The runtimes restart after the update, and Java updates are applied separately, so a release cycle that includes a Java update restarts a runtime twice.
The runtime is a Java application that [requires Java 8 or Java 11](https://help.boomi.com/docs/Atomsphere/Integration/Atom,%20Molecule,%20and%20Atom%20Cloud%20setup/r-atm-Atom_system_requirements_e3656558-174d-438e-bc5a-6dd48d20c159), and Boomi provides [security patches only for runtimes on Java 11](https://help.boomi.com/docs/Atomsphere/Integration/Integration%20management/c-atm-Java_upgrade_FAQ_7235338a-f640-4fa5-89be-c1e4e17f776c).
## Connector retirements {#connector-retirements}
Boomi publishes its [product and feature retirements](https://help.boomi.com/docs/Atomsphere/Platform/atm-Product_feature_retirements), with deprecations normally announced [at least six months in advance](https://help.boomi.com/docs/Atomsphere/Platform/atm-Boomi_feature_deprecation_process_policy_e4547744-664f-4539-bd23-b91676bcbd8a):
| Connector or feature | Status | Date |
| --- | --- | --- |
| Web Services SOAP Client connector | Deprecated | Retirement in November 2026 |
| Marketo connector | Deprecated | Retirement in November 2026 |
| Amazon S3 and Oracle E-Business connectors | Retired | May 30, 2026 |
| SFTP V2 connector | Retired | January 24, 2026 |
| LDAP and MQTT connectors | Retired | March 8, 2025 |
| Database, Disk, FTP, JMS, SAP and SFTP connectors, Atom Queue | Legacy, critical security fixes only | Not announced |
Retired connectors remain in the account and deployed processes continue to run, but the connectors are no longer maintained or supported. Boomi directs customers to [successor connectors](https://help.boomi.com/docs/Atomsphere/Release_Notes/Connectivity/connectivity_nov_2025), such as Amazon S3 REST and Oracle E-Business Suite V2, and each process that uses a deprecated or retired connector is moved to its successor and tested again.
## The retirement of the Boomi SOAP client {#the-retirement-of-the-boomi-soap-client}
The [Web Services SOAP Client connector](https://help.boomi.com/docs/Atomsphere/Integration/Connectors/c-atm-Technology_connectors_2c48c3e3-1a3d-4f5b-ae06-00c35d0439fb) is the connector with which Boomi processes call SOAP services, and the [March 2026 release notes](https://help.boomi.com/docs/Atomsphere/Release_Notes/Connectivity/connectivity_mar_2026) direct customers to the Web Services Server connector instead.
The Web Services Server connector [listens for and accepts](https://help.boomi.com/docs/Atomsphere/Integration/Event-based%20integration/r-atm-Web_Services_Server_connector_b478c2c9-c309-456c-98e8-12ec189e5790) REST, SOAP and HTTP requests that other systems send to Boomi. It does not call SOAP services. For outgoing requests, the same documentation lists only the Web Services SOAP Client connector and the generic HTTP Client connector, so after the retirement a process that calls a SOAP service builds its SOAP envelopes and headers itself and sends them through the HTTP Client.
In Zato, [SOAP](https://zato.io/docs/dev/soap/index.html) is part of the platform in both directions - services receive and call SOAP services, with WS-Security, WS-Addressing, MTOM attachments and ebXML messaging configured in the Dashboard.
## Converting Boomi processes with AI {#converting-boomi-processes-with-ai}
Every Boomi component - a process, a map, a profile, a script or a connection - is defined in XML, and the [Component object of the Boomi Platform API](https://developer.boomi.com/docs/api/platformapi/Component) returns that XML for each component of the account. AI assistants translate it into Python services. An AI assistant reads the components of a process and writes one Python service, with the steps and maps expressed as Python code, the profiles as data models and the Groovy and JavaScript scripts rewritten in Python. With the [Zato documentation connected to it over MCP](https://zato.io/docs/ai/connect-your-copilot.html), the assistant uses the real APIs of the platform.
Each converted service is then reviewed by your developers and tested with messages from the production Boomi runtime. The same message is processed by the Boomi process and by the Python service, and the outputs are compared before the Python service receives live traffic.
## The migration sequence {#the-migration-sequence}
A migration from Boomi proceeds one process at a time, with both platforms running side by side for as long as it takes:
1. **Inventory the processes.** For each deployed process, record its connections and operations, profiles, maps, scripts, schedules, listeners and trading partners.
2. **Define the connections.** Every connection component becomes an outgoing connection in Zato, and every listener and API Service becomes a channel, created in the Dashboard and promoted to the other environments with GitOps.
3. **Convert the processes with AI.** An AI assistant translates the process, map, profile and script components into Python services and data models, and your developers review each service.
4. **Move the trading partner exchanges.** EDIFACT documents from B2B/EDI Management are parsed, routed and serialized by Python services in Zato.
5. **Test with production messages.** Messages from the production Boomi runtimes are sent to the new services, and their outputs are compared with the outputs of the Boomi processes.
6. **Switch the endpoints.** Each calling system, trading partner, file location and queue is pointed to the Zato channel in turn.
7. **Retire the Boomi runtimes.** When the last process carries no more traffic, its deployments are removed and the Boomi runtimes are shut down.
## Where Zato runs {#where-zato-runs}
Zato runs on your own infrastructure - on physical or virtual servers, in Docker and in any cloud. It connects to the [SQL databases](https://zato.io/docs/dev/examples/sql/index.html), [SAP](https://zato.io/docs/dev/sap/index.html), [Salesforce](https://zato.io/docs/dev/salesforce/index.html), REST, SOAP, file transfer and message queue systems that Boomi processes connect today.
Upgrades are applied when your organization schedules them. Integrations are written in Python and administered in the Dashboard, where channels, connections, security definitions and scheduled jobs are created and every message is visible in the audit log, and environments are managed with GitOps, a modern practice in which every environment is built from your own Git repository. Enterprise support is available 24x7x365 from the team that builds Zato.
## Boomi and Zato compared {#boomi-and-zato-compared}
| | Boomi | Zato |
| --- | --- | --- |
| Open source | No | Yes |
| No licensing per connection, runtime or message | No | Yes |
| Integrations as code instead of a drag-and-drop canvas | No | Yes |
| Integrations in the most popular programming language | No | Yes |
| One language for process logic, data mapping and custom code | No | Yes |
| Upgrades applied on your own schedule | No | Yes |
| Development in the IDE of your choice | No | Yes |
| Dashboard for channels, connections, security and the audit log | Yes | Yes |
| Calling SOAP services after November 2026, with WS-Security | No | Yes |
| EDIFACT, REST and SQL in one platform | Yes | Yes |
| Enterprise support 24x7x365 | Yes | Yes |
## Frequently asked questions {#frequently-asked-questions}
### How are Boomi connectors licensed? {#how-are-boomi-connectors-licensed}
Each unique connection component deployed to a runtime consumes one connection license, production and test environments have separate pools of licenses, and a deployment that exceeds the purchased licenses does not complete. On the Pay-As-You-Go plan, every inbound and outbound document of a process, including each response, is billed as a Boomi Message.
### How much have Boomi prices risen at renewal? {#how-much-have-boomi-prices-risen-at-renewal}
Celigo reports price increases of 50 to 100 percent at renewal in some cases after the 2025 pricing changes, which introduced connector capacity and message caps, and Workato quotes former Boomi customers on prices that rose by 50 percent in 18 months.
### Can AI convert Boomi processes to Python? {#can-ai-convert-boomi-processes-to-python}
Yes. The Boomi Platform API returns the XML of each process, map, profile and script, and an AI assistant translates them into Zato services and data models. With the Zato documentation connected to it over MCP, it uses the real APIs of the platform. Your developers review each service and test it with messages from the production Boomi runtime before it takes over the traffic.
### Can Boomi runtime updates be postponed? {#can-boomi-runtime-updates-be-postponed}
No. Boomi states that runtime and platform updates are not optional. A runtime release that was not applied in the two weeks before the platform release is applied automatically, and the runtimes restart after the update.
### Which Boomi connectors are being retired? {#which-boomi-connectors-are-being-retired}
The Web Services SOAP Client and Marketo connectors are scheduled for retirement in November 2026, after the LDAP, MQTT, SFTP V2, Amazon S3 and Oracle E-Business connectors were retired in 2025 and 2026. The Database, Disk, FTP, JMS, SAP and SFTP connectors and the Atom Queue are in Legacy status and receive critical security fixes only.
### What happens to Boomi processes that call SOAP services? {#what-happens-to-boomi-processes-that-call-soap-services}
The Web Services Server connector that Boomi names in place of the SOAP client receives requests but does not call SOAP services. Processes that call SOAP services are rebuilt on the generic HTTP Client connector, or moved to a platform that calls SOAP services natively, such as Zato.
### Does Zato process EDIFACT messages? {#does-zato-process-edifact-messages}
Yes. Zato parses EDIFACT interchanges into Python objects, routes messages by type and serializes them back byte for byte, as shown in the [EDIFACT tutorial](https://zato.io/tutorials/edifact.html).
### Can Zato and Boomi run at the same time? {#can-zato-and-boomi-run-at-the-same-time}
Yes. During a migration both platforms run side by side, and endpoints are moved to Zato one process at a time.
### Is Zato open source? {#is-zato-open-source}
Yes. The source code of Zato is [on GitHub](https://github.com/zatosource/zato).
### How do I get started? {#how-do-i-get-started}
Start the [tutorial](https://zato.io/tutorials/main/01.html) or [schedule a demo](https://zato.io/services/demo.html).
Dariusz Suchojad is founder of Zato Source.
**Planning a move from Boomi? [Request your customized demo today](https://zato.io/services/demo.html).**