Knowledge base, automation

My software has no API. Now what?

If your software has no API, you don't have to switch right away. With a scheduled export, a middle layer or your own build, you can still connect your systems, as long as you know how fragile each route is.

Why a vendor won't give you an interface

You usually only run into this problem when you want to automate something. Invoices need to go from your accounting software to your CRM, inventory needs to sync with your online store, or you want a dashboard that combines numbers from three systems. Then it turns out there's no API, no webhook, nothing. Just an export button and a support rep who says integrations "aren't supported out of the box."

There are usually three reasons behind this. The first is technical. The software is old, built before an API was common, and adding an interface is a big project for the vendor. The second is commercial. Some vendors make money on integrations they build themselves at an hourly rate, and have no interest in an open API that lets customers connect things on their own. The third is strategic. A closed system makes switching harder, and the vendor knows it.

For you as a business owner, the reason doesn't matter much. You have a task you want to automate and a system that won't cooperate. The question is which route you take, what it costs, and where it gets fragile.

Route 1: keep doing manual exports and imports

The simplest route is to change nothing. You export an Excel or CSV file from system A and import it by hand into system B. For businesses that do this once a week or once a month, it's often the cheapest option. No costs, no technical risk, no dependency on an outside party.

The weak spot is the person doing it. When someone is sick, on vacation or leaves the company, the process stops or goes wrong. File formats sometimes change after an update, so the import suddenly stops lining up and nobody notices right away. And the more often you have to do it, the bigger the chance of mistakes, like a wrong column, a duplicate import or a forgotten week.

This route is defensible as long as the frequency is low and the consequences of a mistake are small. Once you have to export every day, or once the data directly affects invoicing or inventory, manual work becomes a risk that makes your business bigger than it needs to be.

Route 2: automate a scheduled export

Many software packages without an API do offer some form of automated export, such as a CSV file that shows up on an FTP server every night, a report that's emailed automatically, or a shared network folder that refreshes every hour. That isn't an API, but it isn't manual work anymore either.

With an automation tool like n8n, Make or Zapier, you can pick up that file as soon as it appears, process the contents and pass them on to the next system. In practice this is called a polling integration. You check at fixed times whether there's new data, instead of the system actively notifying you through a webhook. It works, but with a delay. If the export runs at 3 a.m., you won't know until the next morning what happened yesterday.

The cost is mostly in building the workflow, somewhere from a few hundred to a few thousand euros, depending on how much logic goes into it and how much error handling you want. The weak spot is the file format. If the vendor changes something in the export without warning, the integration breaks silently. You only find out when someone asks why the numbers are off. So always build in a check that alerts you when the file is a day late or has a different structure than expected. You can read more about what an integration like this costs over time in what an integration costs.

Route 3: screen scraping or RPA as a last resort

If there isn't even an export function, there's still one ugly but working route left, a robot that operates the screen the way a person would. This is called Robotic Process Automation (RPA) or screen scraping. The robot logs in, clicks through screens, reads fields and enters data, exactly like an employee would, only automated.

This is the most fragile route of all. Every visual change in the software, a button that moves, a new pop-up window, a text label that changes, can make the robot get stuck. Maintenance is consistently higher than with an API integration or a scheduled export, because you're essentially imitating an interface that was never meant for automation.

Costs vary widely. Simple scraping tasks are relatively affordable to build with tools like n8n or specialized RPA software, but complex screen flows with many steps can be as expensive as custom software. I only recommend this route when there's truly no other option, and with the understanding that you're accepting an ongoing maintenance cost, not a one-time investment.

Route 4: access the database directly

Some systems run on a standard database (for example MySQL or SQL Server) that you can read directly, with permission and the right know-how. This bypasses the vendor completely. You read the tables without going through an export function or interface.

That sounds appealing because it's fast and flexible, but there are serious catches. First, it often violates the software's license terms, especially with cloud software where you're not supposed to have direct access to the underlying database. Second, the structure of that database is undocumented and not stable. An update can change a table name or column without warning, and then your integration stops for no obvious reason.

This route is only worth considering for on-premise software that you (or your IT partner) administer yourself, with explicit permission from the vendor. With cloud software I advise against it. The fragility is too great and the legal risks outweigh the convenience.

Route 5: build your own middle layer

The most solid route when a vendor offers no interface is to build one around it yourself. That sounds contradictory, but in practice it means setting up a small application or workflow of your own that neatly wraps the export, import or scraping and behaves like a real integration to the outside world.

A middle layer like this does three things the separate routes above don't do on their own. It checks whether the data is complete and correct before passing it on, it logs errors so you can track them down before a customer or coworker finds them, and it gives your own systems a stable interface, even when the source underneath changes. If the vendor's export changes, you only adjust the middle layer, not every system that depends on it.

This is essentially custom software, though it's usually a compact tool and not a big system. The investment is higher than a simple workflow, but lower than RPA in the long run, because you're building something meant to run stably instead of imitating an interface. For businesses that keep running into missing interfaces, this is often the smartest choice, because you're buying back predictability. On the automation page I explain how this approach fits into a broader automation project, and in build it yourself or outsource I go deeper into the question of who builds it for you.

Route 6: put pressure on the vendor or replace it

Before you start building, it pays to ask first. Vendors sometimes do grant API access if you show them you're a paying customer with a concrete business reason, especially when an internal API already exists that simply isn't offered publicly or documented. Ask explicitly for an integration, an export API or a partner program for integrations. It costs nothing but time, and sometimes it gets you the exact solution you were looking for.

If that doesn't work, it's time to look at whether the software itself still fits your business. A vendor that consistently refuses to offer an interface is sending a signal about how it sees the future of its product. As your business grows and more and more systems need to talk to each other, a closed package becomes a bigger and bigger brake. Switching is a major step, but sometimes it's the only one that's cheaper in the long run than years of patching things up.

Cost and fragility per route side by side

To make the choice concrete, I've put the six routes side by side below on the two things that really matter, what it costs and where it breaks.

  • Manual export/import: no direct costs, highest fragility because of human error and staff absences.
  • Scheduled export: limited build costs, vulnerable to silent changes in file format, data is never fully up to date.
  • Screen scraping/RPA: variable build costs, consistently high maintenance because it's sensitive to interface changes.
  • Direct database access: low build costs but legal risk and an unstable structure, only for on-premise with permission.
  • Your own middle layer: higher one-time investment, lowest ongoing fragility, best option for repeated use.
  • Replacing the vendor: highest one-time cost and transition risk, but the only route that solves the problem for good.

What stands out is that the cheapest route in the short term (manual work) is almost always the most expensive in the long term, because the costs shift to errors, time and missed opportunities. The reverse is also true. The more expensive routes (middle layer, switching) are often the only ones that actually remove the problem instead of postponing it. You can read more about the broader trade-off between off-the-shelf and connecting things yourself in off-the-shelf software or your own integrations.

When you're better off switching

There's a clear tipping point where patching things up becomes more expensive than switching. You can recognize it by a few signals that often show up together.

  • You're connecting more than two systems to each other and every integration is a separate workaround with no shared structure.
  • You regularly fix broken integrations because the vendor changes something in the export or interface without warning.
  • The data you need is business-critical (invoicing, inventory, customer data), where a mistake directly costs money or trust.
  • You're growing, and the number of times a week you run into the limitation is going up instead of down.

If you see two or more of these signals in your own business, it's wise not to build yet another workaround, but to look into whether different software, or a central dashboard layer that combines multiple sources, works out cheaper in the long run. A good starting point is an audit of your current systems, which maps out which integrations you need and which route fits each one.

How I approach this problem

When a client comes to me with "my software has no API, now what," I never start with the technical solution. I start by asking how often the problem comes up, what the data is worth if it's wrong, and how long the software still fits into the company's plans. Those answers determine whether a simple scheduled export is enough, or whether a middle layer of your own or even a switch makes more sense.

Often a combination works best. In the short term, a scheduled export so you can keep going today, and in the longer term a middle layer or a new system once growth justifies it. That keeps you from building an expensive solution today for a problem that will be gone in a year anyway, and it also keeps you from doing manual work for years on something that could have been automated long ago.

On services you can read how I set up projects like this, from a first export solution to a full integration or a middle layer of your own. And on about you can read why I work on this as an independent builder instead of an agency with a fixed template, because every package, every vendor and every situation calls for a different balance between speed, cost and fragility.

Frequently asked questions.

My software has no API. Can I still automate?

Yes, usually. You can work with a scheduled export, screen scraping or a middle layer of your own that wraps the export as a stable integration. Which route fits best depends on how often you need to connect and how critical the data is.

What does it cost to recreate an integration without an API?

A simple scheduled export workflow often costs a few hundred to a few thousand euros to build. A middle layer of your own that's more stable and keeps up with changes costs more, but saves ongoing maintenance in the long run.

Is screen scraping safe enough for business-critical data?

It can work for one-off or small tasks, but I advise against it for business-critical data. Every visual change in the software can make the robot get stuck, and maintenance is consistently higher than with a real integration.

Am I allowed to access my software's database directly?

With on-premise software and the vendor's permission, sometimes yes, but with cloud software direct database access often violates the license terms and is legally risky. Always check with the vendor first.

When should I just switch to different software?

If you're tying more than two systems together with separate workarounds, regularly fixing broken integrations, or the data is business-critical, switching is often worth more than years of patching things up.

Can I have someone figure out which route fits my situation first?

Yes, that's exactly what an audit is for. It maps out which integrations you need and which route fits your business best in terms of cost and fragility.

Curious where things get stuck for you?

Walk me through one process. In half an hour I'll go through your business and point out where work gets stuck, what it costs now and what an integration would save.

No newsletter spam. One email a month at most, and unsubscribing is just a reply.

Walk me through one process