How We Saved a 3PL from Losing a Major Client by Building the Mirakl-to-Mintsoft Integration That Didn't Exist

Case Study Highlights

• Systems: Mirakl marketplace platform + Mintsoft warehouse management

• Problem: A major client required Mirakl marketplace support, but no native or off-the-shelf integration existed to connect Mirakl to Mintsoft, and the 3PL was at risk of losing the account

• Solution: Custom many-to-many integration: orders from multiple Mirakl stores split into sub-orders and routed across multiple Mintsoft accounts, fulfilment status synced back, cancellations and returns handled, inventory kept accurate with configurable buffer

• Result: Client retained, huge order volumes processed automatically, no overselling, full order lifecycle managed end to end. No existing solution on the market does this

One of the UK’s leading 3PL providers came to us with an urgent problem: they were about to lose a major client.

The company has been in the fulfilment business for over 30 years, running two warehouses and serving clients across fashion, beauty, food and drink, tech, and more. They use Mintsoft to manage their warehouse operations: inventory, picking, packing, dispatch. Their existing sales channels were well connected. Amazon, eBay, Shopify, all plugged into Mintsoft through native integrations. The operation ran smoothly.

Then a major client came to them with a new requirement: they needed their products fulfilled through Mirakl-powered marketplaces. Mirakl is the platform behind some of the biggest enterprise marketplaces in Europe. It was a major sales channel for this client, and supporting it was non-negotiable. If the 3PL couldn’t make it work, the client would move to a provider who could.

The obvious question is: why not just switch to a WMS that supports Mirakl? Because when your entire operation, two warehouses, dozens of clients, hundreds of integrations, runs well on a tool, ripping it out to chase a single missing feature is one of the most expensive mistakes a business can make. You don’t throw away a system that works. You extend it. That’s a core part of how we think about software. The right answer wasn’t to replace Mintsoft. It was to build the custom API bridge that Mintsoft didn’t have.

The 3PL looked for that bridge. There wasn’t one.

Why No Native Mirakl to Mintsoft Integration Exists

This isn’t a case of missing a hidden setting. There is no native integration between Mirakl and Mintsoft, and the reason is structural.

Mintsoft has over 175 integrations. It connects directly to Amazon, eBay, Shopify, and dozens of other platforms. Mirakl isn’t on that list. The reason: Mirakl isn’t a single marketplace the way Amazon or eBay is. It’s the infrastructure that powers hundreds of different marketplaces, each operated by a different retailer. B&Q, Decathlon, Macy’s, they all run on Mirakl but each one has its own API endpoint and its own security protocols. A single “connect to Mirakl” button in Mintsoft would have to account for every one of them.

The middleware options, platforms like Pipe17 or Order Desk, offer separate Mirakl and Mintsoft connectors that you can bridge together. They work for simpler setups: one Mirakl store, one Mintsoft account, straightforward order flow. But the 3PL’s requirements were fundamentally different. They manage many client accounts in Mintsoft. Orders coming in from a Mirakl marketplace need to be split into sub-orders and routed to the correct client accounts. No existing solution on the market does this. The middleware connectors treat Mirakl as a single source and Mintsoft as a single destination. A one-to-one pipe. What this 3PL needed was a many-to-many integration with order splitting and routing logic in the middle.

That limitation wasn’t just a technical inconvenience: it would have forced each Mirakl marketplace to map to a single Mintsoft account. One store, one account. If a marketplace carried products from multiple clients, too bad. The 3PL’s clients couldn’t share marketplace presence, and the business couldn’t structure its operations the way it actually needed to. It was the same kind of forced constraint we’d seen with a client whose sales team had to leave Tradegecko to manually check warehouse stock because the systems didn’t talk to each other. When the tools can’t keep up, the business has to work around them.

They needed something built for their specific setup. That’s where we came in at SaaS Glue.

What We Built: The Custom Mirakl to Mintsoft Integration

Two data flows, both fully automated, built specifically for a multi-client 3PL operation.

Orders: Multiple Mirakl Stores to Multiple Mintsoft Accounts

This is the core of the integration. The system connects to multiple Mirakl-powered marketplaces, pulling orders from each one in real time. When an order comes in, the integration analyses the line items and splits the order into sub-orders, routing each one to the correct client account in Mintsoft with the right SKUs and quantities. The warehouse picks and packs each sub-order independently.

Here’s what that looks like in practice. A single marketplace order might contain a beauty product fulfilled by one client and a tech accessory fulfilled by another. The order arrives from one of several Mirakl stores, gets broken apart, and the pieces land in the right Mintsoft accounts ready for the warehouse to pick. Multiply that across multiple marketplaces, each sending orders that need to be split and routed differently, and you start to see why the off-the-shelf connectors don’t cut it. Those tools assume a one-to-one relationship: one marketplace, one fulfilment account. This is many-to-many with routing logic in between.

The mapping layer was the tricky part. Each client has their own product catalogue in Mintsoft with their own SKUs. Each Mirakl-powered marketplace uses its own product identifiers, and different marketplace operators structure their catalogues differently. A single product might have one SKU in Mintsoft, a different reference in one Mirakl store, and yet another identifier on a different marketplace. We built a configurable mapping engine that handles the translation across all of them, so when a new client starts selling on a new Mirakl marketplace, the ops team sets up the mapping once and every order after that flows through and splits automatically.

Once the warehouse dispatches a sub-order, the integration picks up the fulfilment status from Mintsoft and syncs it back to Mirakl. The marketplace order gets updated as each part ships, the customer gets their tracking details, and nobody had to copy a single status between screens. If an order was split across three client accounts, all three fulfilment updates flow back to Mirakl independently as each one completes. Partial fulfilment works exactly the way you’d expect: if two of three sub-orders have shipped and the third is still being picked, Mirakl reflects that accurately.

Cancellations flow through the integration too. If an order gets cancelled on the marketplace, the system catches it and updates Mintsoft before the warehouse wastes time picking something that isn’t needed anymore. Returns are handled the same way: when returned stock arrives back in the warehouse and gets booked into Mintsoft, the inventory update flows through to Mirakl so the listing quantities stay correct.

Inventory: Mintsoft to Mirakl

Stock levels sync from Mintsoft to Mirakl across all connected stores on a regular cycle. Every time inventory changes in the warehouse, whether from new stock arriving, orders being dispatched, returns being processed, or adjustments being made, our real-time inventory synchronization ensures the data flows through to every relevant Mirakl marketplace, complete with stock buffer logic to prevent overselling.

Without this, overselling would have been inevitable. Even if someone had tried to manage inventory manually through spreadsheets, the updates would always lag behind reality. By the time someone exported the numbers from Mintsoft, formatted the file, and uploaded it to Mirakl, the data could be hours old. The automated sync closes that gap entirely. We also built in a configurable stock buffer, so the system can hold back a safety margin rather than advertising every last unit on the marketplace. If a client has 50 units in the warehouse and sets a buffer of 5, Mirakl shows 45 available. It’s a simple mechanism but it kills overselling dead, especially during high-volume periods when stock is moving fast.

We built in safeguards for edge cases. If the Mirakl API is temporarily unavailable, inventory updates queue up and push through as soon as the connection recovers. If a SKU mapping is missing or ambiguous, the system flags it rather than silently skipping it or pushing wrong data. The ops team gets a clear alert and can fix the mapping before it becomes a problem.

Keeping It Running

A sync that runs between two systems multiple times a day needs to be watched. If it silently breaks, nobody would know until orders start going missing or stock goes out of sync, and by then the damage is done.

We set up monitoring with Grafana and Rollbar. Grafana tracks sync health: how many orders have been pulled from Mirakl, how many successfully pushed into Mintsoft, inventory update frequency, and any failed or queued operations. Rollbar catches exceptions and errors in real time. If an API call fails, a mapping breaks, or something unexpected comes back from either system, we know about it before the client does.

When the 3PL onboards a new client who sells on a Mirakl marketplace, the monitoring picks up the new data flow immediately. We can see whether orders are syncing correctly and whether inventory updates are landing as expected, without waiting for someone to report a problem.

What Changed

The 3PL kept their client. That was the immediate win. But the integration didn’t just solve the original problem, it opened up a capability the business didn’t have before.

The client is now processing a huge volume of marketplace orders through the integration, all flowing automatically from multiple Mirakl stores into the right Mintsoft accounts. The full order lifecycle works end to end. Orders come in and get split across client accounts. Partial fulfilment updates flow back as each sub-order ships. Cancellations get caught and propagated before the warehouse picks stock that’s no longer needed. Returns get processed and the inventory lands back on the marketplace listings. Stock levels stay accurate with the buffer keeping overselling in check.

Before, any Mirakl integration would have locked each marketplace to a single Mintsoft account because that’s all the existing tools could handle. That constraint is gone. Multiple clients can sell through the same marketplace, orders get split and routed automatically, and the 3PL can structure its operations around what makes business sense rather than what the tools allow.

And then it started paying for itself in a way nobody planned. The integration that was built to save one client became the pipeline for winning new ones. With the Mirakl-to-Mintsoft infrastructure already running, onboarding a new client who sells on a Mirakl-powered marketplace is just a configuration task: set up the SKU mapping, connect the store, and orders start flowing. The thing that nearly cost them a major account is now the reason new clients pick them over competitors who still can’t support Mirakl.

Frequently Asked Questions – Mirakl & Mintsoft Integration

Is there a native Mirakl Mintsoft integration or 3PL connector?

No. Mintsoft does not have a native Mirakl integration, and no off-the-shelf 3PL connector handles the many-to-many order splitting this use case requires. That’s exactly why we had to build it from scratch.

Why not use Pipe17, Order Desk, or another off-the-shelf connector for Mirakl to Mintsoft integration?

Those platforms offer separate Mirakl and Mintsoft connectors that can be bridged together, and for simpler one-to-one setups they work fine. But no existing solution handles the many-to-many routing this client needed: multiple Mirakl stores feeding into multiple Mintsoft accounts with order splitting and routing in between. Those connectors assume one source and one destination. When the setup is this specific, building the integration yourself is more reliable and easier to maintain than bending a generic tool into shape.

Could this work with other marketplace platforms besides Mirakl?

Yes. The approach is the same for any marketplace with an API. We just need to understand the platform’s order structure and inventory update mechanism.

Could this work with a WMS other than Mintsoft?

Yes. The integration maps data between the two systems, so as long as the WMS has an API, we can connect it. We’ve worked with plenty of warehouse and order management systems.

What happens when a new client needs to be onboarded?

The ops team sets up the SKU mapping for the new client and the integration handles the rest. It’s a configuration step, not a rebuild.

How long did this take to build?

Around five weeks end to end, split between development and testing. The core order and inventory sync was up first, then we spent time making sure edge cases were handled properly before going live.

What does it cost?

It depends on complexity: how many Mirakl marketplace accounts, how many clients, and how messy the SKU mapping is. We start with a discovery phase to understand the data and quote from there. No surprises.

Losing clients because your systems can’t keep up with their requirements? Drop us a message. No pitch, just a conversation.

You can also see more of our work or read our manifesto to understand how we approach these problems.