Knowledge base, automation
What does an integration between two systems cost?
The price of an integration between two systems depends on four factors: the interface, the number of fields, the frequency, and who fixes it when it breaks. I work through two real-world examples, so you see a concrete amount instead of a range.
Why "between 500 and 5,000 euros" tells you nothing
Almost every page about integrations ends with a range. Somewhere between five hundred and five thousand euros, depending on the situation. That isn't an answer. It's a disclaimer dressed up as pricing information. As a business owner, you want to know what your integration will cost, not what an average client once paid for something that may look nothing like your case.
The problem is that an integration isn't a fixed product. It's the sum of choices that play out differently at every company. Connecting two packages that both have a modern API is a different project from hooking a legacy point-of-sale system with no documentation at all up to a webshop. Both are called "an integration," but the bill differs by a factor of five to ten.
In this article I break the price down into the four items that actually determine the amount. Then I work through two examples in full, from simple to complex, so you can judge for yourself which category your situation falls into. If you want to look at automation more broadly than a single integration between two systems, automation gives an overview of everything it covers.
The four items that actually set the price
Every quote for an integration is made up of the same four building blocks, whether the builder names them that way or not. If you know the answers to these four questions, you can make a reasonable estimate yourself before a quote is on the table.
- Does the package have an interface, such as an API or webhook, or does something need to be built to pull data out of it?
- How many fields and records need to come along, and how clean is that data right now?
- How often does the integration need to run: continuously, every night, or at the push of a button?
- Who fixes it when the integration stops one day, and what does that cost on an ongoing basis?
The rest of this article covers each item separately, with the reason it pushes the price up or down. After that come two complete worked examples.
Item 1: does the package have an interface?
This is the item that causes the biggest price difference. If a package has an API or a webhook, a builder can pull data from it or send data to it directly, following a fixed structure. The documentation already exists, the authentication has been worked out, and the error messages are predictable. That saves hours of build time and, just as important, hours of maintenance later.
If a package has no interface, there are two routes. The first is exporting and importing files, which works but is slow and error-prone as soon as someone changes the format of an export. The second is driving a system through its user interface, often called robotic process automation, where software pretends to be a person clicking and typing. That works too, but it's fragile. If the vendor changes something on the screen, the integration stops until someone adjusts it.
In concrete terms, an integration between two packages that both have a well-documented API usually costs a fraction of one where one of the two systems offers no interface at all. So ask about this first when you request a quote. Don't ask "can you connect this?" Ask "does this package have an API we can use?"
Item 2: how many fields and records need to come along?
The second item is often underestimated. An integration that only passes on name, email address and order number is fundamentally different from one that carries forty fields, including address details, discount codes, VAT rates and historical notes. Every field that comes along means decisions. What is it called in system A, what is it called in system B, what format does the target system expect, and what happens when the field is empty?
Then there's the state of the data. Are there duplicate customer records in the CRM, do two departments use different product codes for the same item, or are phone numbers stored in five different formats? Then that mess has to be cleaned up first or normalized automatically during the integration. The cleanup often takes more time than the integration itself.
A rule of thumb that holds up well in practice is to count in number of fields times complexity per field, not in "one integration." Ten simple fields that are always filled in can be mapped in a day. Ten fields where half depend on another value, or need validation, easily cost twice as much.
Item 3: how often does the integration need to run?
The third item is frequency, and it shapes the architecture as well as the build cost. An integration that runs once a night can often be set up with a simple scheduled task or a no-code tool. If something goes wrong, you see it the next morning and fix it calmly.
An integration that has to respond in real time, for example because a customer needs to see an order confirmation right after checking out, calls for a different setup. Then you build on webhooks or events, with error handling that steps in immediately when something goes wrong, and with monitoring that raises the alarm within minutes instead of the next day. That reliability takes extra build time, and you see it in the price.
Manually triggered integrations, where someone presses a button when needed, are often the cheapest to build, but they shift the cost to the person who has to keep pressing that button. Count that as a hidden cost item. An employee's time is money too, even if it's not on the integration invoice.
Item 4: who fixes it when it stops?
This is the item most quotes quietly leave out, and the one that causes the most discussion afterward. An integration that works perfectly today will stop at some point. A vendor changes its API, a password expires, a field gets a new name, or one of the systems goes offline temporarily for maintenance. That doesn't happen because the integration was badly built. It happens because third-party software keeps changing.
The question then is who notices that the integration is down, and who repairs it? Without monitoring, you only find out when a customer calls to say their order never reached the system, or when the bookkeeper discovers a month later that invoices are missing. With monitoring, you get an alert as soon as something goes wrong, and it can be fixed within a few hours instead of being discovered weeks later.
So count this as a separate cost item, apart from the build cost. Some integrations are built once with no follow-up agreement, which is fine for something small and stable. Once the integration is business-critical, a fixed agreement on maintenance and repairs is often cheaper than paying for a rush job every time it breaks. With the services I offer, maintenance comes standard for an integration that keeps running long term, and I'm happy to talk through what that means in your case via the contact page.
Worked example 1: two standard packages with an API
Say you want new customers in your CRM to be created automatically as debtors in your accounting software. Both packages are well-known, widely used software with a well-documented API. Eight fields need to come along: name, address, email, phone number, customer number, VAT status, payment terms and a notes field. The integration doesn't need to be real time, syncing once a night is plenty. Errors don't need to be flagged within minutes, an alert the next morning is enough.
In this scenario the build is fairly straightforward: an interface on both sides, a limited number of fields, low frequency, light maintenance. In practice, this type of integration can often be built for somewhere between a few hundred and around a thousand euros one time, with a small monthly amount for monitoring and handling small changes on either side. The biggest cost item here isn't the building itself but testing it properly. What happens with a customer who already exists, with an empty field, or with a duplicate entry?
Worked example 2: an integration with no interface and with logic
Now a different scenario. An outdated inventory system with no API has to pass current stock levels to a webshop, and it has to happen almost in real time, because otherwise you sell products that are no longer in stock. Forty fields need to come along, including bundled items, different sizes and colors, and a calculated availability based on several warehouses. On top of that, there has to be logic in it. When stock goes negative, the item has to go offline automatically, and after a correction it has to come back online.
Here all four items weigh heavily. No interface means a way to pull data out of the inventory system has to be built first, for example through an intermediate layer that reads the system periodically. Forty fields with dependencies between them call for careful mapping and testing. The required speed calls for an architecture that runs continuously instead of a nightly task. And because a wrong stock level hits customers and revenue directly, solid monitoring with fast error handling is a necessity, not a luxury.
A project like this easily runs to several thousand euros, with a correspondingly larger monthly maintenance budget, because the fragility is simply greater. That's no reason to skip it if the business problem is big enough, but it is the reason "an integration" has no fixed price. If you want to look beyond the integration itself for projects like this, for example at the workflow around the entire inventory process, you'll find background in the knowledge base.
What most quotes forget to include
Besides the four main items, there are a few smaller things that can make the difference between a quote that holds up and one that disappoints later. Ask about these points before you accept a price.
- What happens when the authentication, such as an API key or token, needs to be renewed after a while?
- Does either system limit the number of calls per hour, and what if you outgrow that limit?
- Is it tested in a separate environment before the integration runs on real customer data?
- Is there documentation of how the integration works, so someone other than the builder can understand it when it fails?
- What happens when one of the systems is temporarily offline for the vendor's own maintenance?
A quote that covers these points is usually more reliable than one that just states a total with no explanation. Feel free to ask, even if the builder doesn't bring it up.
Want to know how I approach projects like this, or just talk through your specific situation before you request a quote? Read more about how I work, or take a broader look at everything automation can do for your business.
Frequently asked questions.
What does an integration cost on average for a small business?
That depends entirely on the four items in this article. Connecting two standard packages with an API often comes to around a thousand euros one time, while an integration with no interface and a lot of logic easily runs into the thousands.
Can I build an integration myself with a no-code tool?
If both systems have an interface and only a limited number of fields are involved, that's often perfectly doable. Once logic, error handling or large data volumes come into play, building it yourself gets time-consuming and error-prone.
What does maintenance of an integration cost per month?
That depends on how critical the integration is and how often the systems on the other side change. A light integration with little risk needs little maintenance, while a real-time integration with business-critical data needs more monitoring on an ongoing basis.
How long does it take to build an integration between two systems?
A simple integration between two packages with an API can often be done in a few days, testing included. An integration with no interface, many fields and real-time requirements is more likely to take weeks.
Is an integration without an API always much more expensive?
In almost every case, yes, because a way to get data out of the system has to be built first. That takes extra build time and makes the integration more fragile, which also makes maintenance more expensive.
What's the difference between an integration and full automation?
An integration makes data flow between two systems. Automation often goes a step further and adds decisions, actions or workflows that act on that data on their own.
More on automation.
Automate management reporting with live dashboards explainer
Automate your management reporting with API integrations and live dashboards. No more manual data entry, and a direct grip on your numbers.
→ Readfrom real workWhat is the financial return of connecting software? explainer
Calculate the payback period and see the direct financial impact of smart system integrations. Save hours and prevent costly mistakes.
→ Readfrom real projectsWhat automating processes costs a small business explainer
Learn what process automation costs a small business and when it pays back. Save hours of manual work now and prevent errors with smart integrations.
→ Readfrom the fieldSmart automation for customer service & administration explainer
See what an AI assistant actually does for customer service and administration in your small business. Practical examples and a GDPR-compliant approach.
→Curious where work gets stuck for you?
Walk me through one process. In half an hour I go through your business and point out where work gets stuck, what it costs now and what an integration would save.