Let’s be honest—most of us are drowning in APIs. Between legacy systems, SaaS tools, microservices, and third-party integrations, the average enterprise stack looks more like a jigsaw puzzle with no edge pieces. And yet, we’re expected to make everything talk to each other like it’s no big deal.
I’ve been there. I’ve felt the pain of manually stitching together inconsistent APIs, juggling different response formats, dealing with flaky auth, and trying to create a single, reliable service layer on top of all of it. That’s exactly why I’m writing this—because you don’t have to keep doing it the hard way.
Enter Martini.
Martini is Lonti’s low-code platform built for developers like us. It lets you integrate, orchestrate, and automate across any number of APIs—without giving up control. And today, I’ll walk you through how I used it to combine multiple APIs into a single, unified service that actually made sense.
Here’s the scenario: I was working on a dashboard that needed to pull customer data from a CRM API, order data from an eCommerce platform, and support ticket statuses from a helpdesk system. All three had their own APIs. All three were structured differently. None of them played nice out of the box.
What I needed was a unified endpoint—one service I could call to get a full customer profile, enriched with orders and support history. One clean response, no duct tape.
In Martini, I created a new service that acts as my orchestration layer. Think of it like a smart wrapper that handles the API calls, transforms the data, and gives back a single response.
Here’s how I did it:
The first step was to bring each external API into Martini using the Consume API wizard. This tool is seriously underrated—it walks you through importing REST (via OpenAPI spec, Postman collection, or even manually), GraphQL (via schema), or SOAP (via WSDL).
In my case, I had a mix of OpenAPI specs and a WSDL file (because of course I did), and Martini handled all of it smoothly.
Once consumed, Martini automatically generated reusable services for each operation in the API. That means I didn’t have to define endpoints manually or write plumbing code just to call an external service. Everything I needed was already packaged as callable services inside Martini—clean, consistent, and ready to orchestrate.
Honestly, this saved me hours. And because each operation is reusable, I could drop them into workflows, reuse them across projects, or version them independently. Low code that actually respects dev workflows? Yes, please.
Next up: creating workflows—Martini’s visual editor for building workflows. This is where the magic happens.
I dragged in the three API connectors, defined the execution order (CRM first, then orders, then tickets), and used Martini’s mapping tools to extract the fields I needed from each response.
Need to combine customer name from the CRM with their recent orders? No problem. Need to conditionally call the support API only if the customer has open tickets? Easy.
You can handle branching logic, loops, error handling, and transformations—all visually. And if you ever hit something too niche for low code? Just inject custom logic where needed.
Once the data was flowing, I created a response model—a unified structure that wrapped everything into a single, clean JSON object. Martini’s built-in transformation tools let me flatten, reshape, and rename fields without writing boilerplate code.
So instead of three API calls and three weirdly shaped payloads, I now had one smart endpoint returning:
{
"customer": { ... },
"orders": [ ... ],
"supportTickets": [ ... ]
}
Exactly what I needed.
With everything wired up, I used Martini to publish these orchestration workflows as a REST API. One URL, one request, one response. Fully documented via OpenAPI, secured with OAuth2, and ready to plug into any frontend, mobile app, or reporting tool.
You can even version it, monitor it, and test it right inside Martini.
Let’s break it down:
And most importantly? It scaled. I could reuse the same approach to add new services, adapt to schema changes, and evolve the unified API without breaking consumers.
Too many “low-code” tools promise simplicity but fall apart the second you try to do something real. Martini flips that script. It gives you the speed of visual development with the power and flexibility of real code. You can build unified APIs, automate workflows, and connect the most complex systems—without hacking your way through it.
If you’re dealing with API chaos and want to create a single source of truth for your services, give Martini a try. You might just wonder why you ever did it the hard way.
Want to see what you can build with Martini?
👉 Try the Free Edition — no limits, just launch.