We’ve all been there. You’re tasked with building a customer dashboard or integration that pulls data from three totally different APIs—one for CRM data, another for eCommerce orders, and a third for support tickets. Each one structured differently. Auth handled differently. Formats? All over the place.

What should be a simple integration quickly turns into a spaghetti nightmare of fetch calls, transformation scripts, retries, and error handling hacks.

Been there. Done that. Never again.

This time, I used Martini, Lonti’s low-code-but-dev-friendly platform. And for once, the integration didn’t make me want to flip a table.

Let me walk you through what I built—and more importantly, how I built it.

🔍 The Challenge: Disjointed APIs, Disconnected Data

My goal was to create a single endpoint that returned a unified customer profile, complete with recent orders and any active support tickets. The kind of thing your front-end or reporting team loves.

But the systems involved?

• A CRM API (REST, fairly clean)
• An eCommerce system (also REST, less clean)
• A support platform (yep, SOAP via WSDL 😅)

Normally this would be a slog. But in Martini, I was able to stitch these together visually, with full flexibility under the hood.

🧱 Step One: Connect to All Three APIs

Martini’s Consume API wizard handled the API setup. I imported the OpenAPI docs for the CRM and eCommerce systems, and uploaded the WSDL for the support tool.

Martini auto-generated services for every endpoint—meaning I didn’t have to manually wire anything. Each service became a reusable block I could drop into a workflow later.

🧭 Step Two: Build the Workflow Visually

With the services ready, I jumped into Martini’s workflow builder—a low-code visual editor that actually respects developer needs.

• First, I fetched the customer data from the CRM.
• Then I pulled in the order history from the eCommerce API.
• Finally, I added a conditional branch that called the support API only if certain criteria were met.

No special syntax, no “workflow scripting language”—just visual logic. And when I needed to add a custom transformation? I just injected a quick Groovy snippet.

🧹 Step Three: Normalize the Response

This part usually sucks—trying to mash together three different response shapes into one consistent format. But Martini’s response modeler and mapping tools made it simple.

I created a structure like:

{
  "customer": { ... },
  "orders": [ ... ],
  "supportTickets": [ ... ]
}

Then I mapped the fields from each service call into the unified structure, transforming and flattening where needed.

🌐 Step Four: Publish as a Unified API

Once the workflow was ready, I clicked “Publish” and—boom—Martini turned it into a RESTful API, complete with OpenAPI docs and OAuth2 auth. Just like that, I had a single endpoint that wrapped multiple services, handled conditional logic, and gave consumers a clean, predictable response.

No gateway configs. No DevOps rabbit hole. Just one platform doing what it should.

💡 Why This Matters

I’ve stitched together enough APIs over the years to know that most “integration tools” fall apart when real complexity shows up. What set Martini apart?

• It’s low-code, but not limiting. You can drop into code when needed.
• It handles API orchestration natively—no third-party glue required.
• You get built-in observability and version control out of the box.
• Most importantly, it made this project not only fast—but sustainable.

This wasn’t just a demo. It’s a production-ready approach I’ll use again.

✅ TL;DR

You don’t need to choose between speed and control. You don’t need to write 500 lines of glue code just to call a few APIs. And you don’t need to fear SOAP anymore (well, not as much).

Martini let me turn a chaotic 3-API integration into a single, clean endpoint—in a fraction of the time.

Original source: Combining Multiple APIs Into a Unified Service Using Martini