Connect your website to your ERP or invoicing software: integrations and APIs explained

If you have a website or an online shop and also an ERP or invoicing program, chances are someone on your team spends part of every day copying data from one place to another. An order comes in through the website and has to be entered into the invoicing system. Stock arrives at the warehouse and the shop has to be updated by hand. A customer fills in a form and their details end up in an email that nobody moves into the CRM. Every copy is wasted time and another chance to get something wrong.

The solution has a name: integration. Getting your programs to talk to each other and pass information along on their own. In this article I explain, without unnecessary jargon, what APIs and webhooks are, which integrations make the most sense for a small business, when a tool like Zapier is enough and when a custom connection pays off, and above all what can go wrong and how to monitor it so you don't discover a failure three weeks too late.

An API is the service window through which one program lets another ask it for things or hand it data. Think of a restaurant: you don't walk into the kitchen, you give your order to the waiter, who passes it on and brings you the dish. The API is that waiter. Your online shop doesn't go into your ERP's database; it asks “give me the stock for product X” or hands over “here is a new order”, and the ERP answers according to a fixed set of rules.

Most modern business software, from the best-known ERPs to many cloud invoicing tools, offers a documented API. Shops do too: WooCommerce, for example, publishes its REST API to read and modify orders, products and customers. If you want a slightly more technical definition, the one from MDN is among the clearest. What matters to you is this: if both of your programs have an API, they can almost certainly be connected. If one of them doesn't, things get complicated, and it's worth knowing that before you choose software.

With an API, one program asks another. The problem is how often: if your ERP checks the shop every hour for new orders, you can have up to an hour's delay, and if it checks every minute, you're asking thousands of questions for nothing. This is where webhooks come in.

A webhook is an automatic notification. Instead of asking over and over, you tell the shop: “when an order comes in, let me know at this address”. The moment the customer pays, the shop sends the order details and your system processes them instantly. It's like going from checking the mailbox every five minutes to having the postman ring the doorbell.

In practice, good integrations combine both: webhooks to find out what's happening in real time, and API calls to fill in missing information or to check periodically that nothing has been lost along the way.

You don't need to connect everything to everything. In most businesses there are three or four flows that account for almost all the manual work. These are the ones I see most often:

• Stock synced between the ERP and the shop. The ERP is the source of truth for inventory and the online shop always shows the real units available. No more selling something you don't have, or showing a product as out of stock when it's sitting in the warehouse.
• Orders that reach invoicing on their own. Every web sale automatically creates the order or invoice in your management software, with the right customer, lines, taxes and payment method.
• Customers and contacts in the CRM. Anyone who buys, requests a quote or subscribes shows up in the CRM with their history, without anyone copying anything from an inbox.
• Status updates back to the website. When the order is prepared or shipped in the ERP, the shop reflects it and the customer receives a notification with their tracking number.
• Prices and catalogue. If you manage price lists or product details in the ERP, the website updates them without you having to maintain two catalogues side by side.

If you want a broader view of which tasks are worth automating in general (emails, reminders, reports), you'll find it in my guide on how to automate your business tasks. Here I focus on connecting systems, which is usually where the biggest savings are, and also the biggest risks.

There are two main ways to connect your programs. Neither is better in the abstract; it depends on volume, complexity and how much is at stake if something fails.

No-code automation tools

Zapier, Make and n8n act as intermediaries: they have ready-made connectors for hundreds of applications and let you build “when this happens in A, do that in B” flows by dragging blocks around. n8n can also be installed on your own server. They are an excellent option to get started, for simple flows, and to test whether an automation is worth it before investing more.

• Pros: quick to set up, low initial cost, and you don't need to code for small changes.
• Cons: they usually charge per execution, which gets expensive as volume grows; complex logic becomes hard to maintain; and you depend on a connector for your ERP existing and being well built.

Custom integration

A direct integration is code that connects your systems' APIs without intermediaries, usually hosted on your own server or alongside your website. It takes more work up front, but gives you full control over how data is transformed, how errors are handled and what happens when something doesn't add up.

• Pros: no per-operation cost, business logic as complex as you need, better error handling and retries, and your data doesn't pass through third parties.
• Cons: higher initial investment, and you need someone to maintain it when one of the programs changes its API.

Mixed approaches work too: a no-code tool for secondary flows (internal alerts, adding people to a mailing list) and a custom connection for the core of the business. In my automation projects I often start this way, because it lets you move fast without putting anything that touches invoicing at risk.

Connecting two programs is the easy part. The hard part is keeping the connection working properly when odd things happen, and in the real world they happen all the time. These are the most common problems:

1. 1Duplicates. A webhook is sent twice (many systems retry if they don't get a reply in time) and the order lands in invoicing twice. A good integration identifies each operation uniquely and discards one it has already processed.
2. 2Silent errors. The ERP rejects an order because a field is missing (a mistyped tax ID, a product without a reference) and nobody notices. The website says everything is fine, but that order never reaches invoicing.
3. 3Data that doesn't match. The shop and the ERP don't name things the same way: taxes, payment methods, product variants, shipping costs. If the mappings aren't defined properly, the data arrives, but it arrives wrong.
4. 4API changes. Software vendors update their APIs and sometimes what used to work stops working. Without maintenance, an integration degrades over time.
5. 5Temporary outages. If the ERP is down for maintenance just as an order comes in, the integration has to store it and retry later, not lose it.

None of these problems is a reason not to integrate. They are a reason to integrate properly: with retries, duplicate control and, above all, monitoring.

An unmonitored integration is a ticking time bomb. It works perfectly for months until it doesn't, and you find out when a customer asks for an invoice that was never issued. These are the measures I always include:

• A log of every operation. What came in, when, what was done with it and with what result. If something fails, you have the full trail.
• Alerts when something fails. An immediate email or message with the specific error, not a failure buried in a log nobody reads.
• A retry queue. Anything that couldn't be processed is stored and retried automatically; if it keeps failing, it goes to a list for manual review.
• Periodic reconciliation. Once a day or once a week, a process compares both sides: are the same orders on the website and in invoicing? Does the stock match? Differences are flagged before they become a problem.
• A simple dashboard. One glance to see how many operations have been processed, how many have failed and which are pending.

Before writing a single line of code or building the first flow, it pays to answer a few questions. They'll save you surprises:

1. 1Does your ERP or invoicing software have an API? Is it documented? Does it cost extra or have usage limits?
2. 2What is the source of truth for each piece of data? Stock usually lives in the ERP; contact details, perhaps in the CRM. If two systems can change the same thing, you have to decide which one wins.
3. 3What volume do you handle? Ten orders a day is not the same as a thousand.
4. 4What happens if the integration stops for a day? Can you keep working by hand while it's fixed?
5. 5Who will maintain it when something changes? An integration is not a project you deliver and forget.

If you don't have a CRM yet, or yours has no API, it may make sense to consider a custom CRM that is connected to your website and invoicing from day one, rather than forcing a connection with a tool that wasn't designed for it.

Integrating your website with your ERP, CRM and invoicing software is not just for large companies. With the APIs and webhooks that almost any software offers today, a small business can cut hours of manual work every week and, above all, the errors that come with it. The key is choosing what to connect first, deciding which tool to use based on volume and what's at stake, and never forgetting monitoring: retries, alerts and reconciliation.

I'm Elmar Mamedova, a full stack developer based in Málaga. A good part of my work is getting my clients' software to understand each other: shops that talk to the ERP, forms that feed the CRM and orders that reach invoicing on their own, always with logs and alerts so nothing fails silently. If someone in your business spends hours moving data from one screen to another, tell me about it and we'll see how to take that work off their plate.