# API Integration Cost: What a Small Integration Takes

> A simple one-way API integration between two systems with good documentation typically takes around 12 to 28 hours, so roughly $1,200 to $2,800 at a $100 hourly rate. Two-way sync, poor documentation or high volumes can multiply that. Budget separately for hosting, monitoring and upgrades whenever either API releases a new version.

- URL: https://kleinerauftrag.de/en/costs/api-integration-cost/
- Language: en
- Updated: 2026-10-19
- Publisher: Kleiner Auftrag (OnlineBuilders LLC, https://onlinebuilders.biz)

Two quotes for "connecting our shop to our accounting software" can be $900 and $4,500, and both developers can be honest. They simply priced different integrations. One assumed paid orders only, flowing one way, with no error handling. The other assumed refunds, partial payments, foreign currencies and an email when anything fails.

So before talking money, it pays to know what you are actually asking for.

## Three ways to connect two systems

Check the cheaper routes before paying for code. Many shop and accounting platforms ship ready-made connectors you simply switch on. Automation services such as Zapier or Make link popular apps with a few clicks, for a monthly fee.

**Native connector, automation tool or custom integration**

| | Native connector | Automation tool | Custom integration |
|---|---|---|---|
| Upfront cost | low | low | high |
| Running cost | subscription or app fee | monthly fee, grows with volume | hosting and upkeep |
| Follows your own rules | no | partly | yes |
| Handles high volumes | partly | no | yes |
| Data stays under your control | partly | no | yes |

Custom code makes sense when the ready-made routes break on your edge cases, when monthly fees climb too steeply with volume, or when you'd rather not send sensitive data through yet another service.

## Seven questions that set the price

Seven questions decide whether an integration takes two days or two weeks. Any developer will ask them, so you may as well answer them in your [brief for the developer](https://kleinerauftrag.de/en/scoping/how-to-brief-a-developer/).

1. **Direction:** does data only flow from A to B, or do changes need syncing both ways? Two-way isn't twice the work, it's often more, because conflicts have to be resolved.
2. **Trigger:** can the source system send a webhook, or does the integration have to poll?
3. **Documentation:** is there public API documentation with examples, and a sandbox to test against? Without them, developers experiment, and experiments are billable.
4. **Authentication:** is a simple API key enough, or does it use OAuth 2.0 with access tokens that expire and must be refreshed?
5. **Mapping:** how do fields translate? Product codes, tax rates, payment methods and countries are named differently in every system.
6. **Volume and limits:** how many records a day? Public APIs usually cap requests per time window, and the documentation says by how much.
7. **Failure:** what should happen when a transfer fails? Retry, alert someone, log it?

Question seven is the one people tend to skip, client and quote alike. An integration that gives up silently goes unnoticed until month-end, when twenty invoices are missing.

## Worked example: shop to accounting, one way

Here's how a quote for a modest integration might break down, say Shopify sending paid orders to Xero or QuickBooks. Both systems here have well-documented APIs with test access. The hours are assumptions for illustration. The rate is a $100 example, roughly the US break-even rate from our article on the [freelance developer hourly rate](https://kleinerauftrag.de/en/costs/freelance-developer-hourly-rate/).

**Example: paid orders sent to accounting as sales invoices**

- Read API docs, set up sandbox access (2 h): $200
- Receive webhook for paid orders (3 h): $300
- Map fields: tax rates, shipping, discounts (4 h): $400
- Create invoice in accounting system (3 h): $300
- Retries, email alerts, logging (4 h): $400
- Edge-case testing, handover, short docs (4 h): $400
- **20 hours: $2,000**

Assumed hours for an example with two well-documented APIs, at a $100/h example rate.

What's missing: credit notes for refunds, partial payments, orders in foreign currency. Each can add a few hours. Work out which of these actually occur in your business. If you never sell in euros, you shouldn't pay for euro handling.

Two-way sync, such as stock levels between a shop and an inventory system, easily lands at two or three times this. Then someone has to decide which system wins when stock changes in both places at once.

## What a usable quote spells out

Quotes for the same integration can differ several times over, and that's rarely greed or dumping. Each developer makes different assumptions. One includes proper error handling, the other a script that simply stops when something goes wrong. Quotes only become comparable when those assumptions are written down.

Make sure these points appear explicitly:

- which data moves in which direction, with an example
- which trigger is used and what delay to expect
- which edge cases are covered and which are explicitly not
- how failures are reported, and to whom
- where the code runs, and who pays for and looks after that place
- whether you receive the source code and who holds the rights
- the hourly rate for later changes

That second-to-last point gets forgotten. Without source code and usage rights, every change ties you to the original developer. Our article on [who owns the code](https://kleinerauftrag.de/en/delivery/who-owns-the-code/) covers what to agree.

If error handling is missing from a quote entirely, ask. Cheaper without it isn't cheaper. It just moves the cost to the day something breaks.

## Running costs after launch

An integration isn't furniture you assemble once. It hangs between two systems that evolve without asking you. Shopify, for instance, releases a new API version every three months and supports each stable version for at least twelve months, according to its [developer documentation](https://shopify.dev/docs/api/usage/versioning). Running an integration against it means checking at least once a year whether you need to move to a newer version.

Typical ongoing items:

- hosting: the server, cloud function or plugin where the code runs
- monitoring: who reads the failure emails, and what happens during holidays?
- upgrades when either API releases a new version
- extensions when new payment methods or tax rules arrive

Ask the developer how many hours a year they expect for upkeep and at what rate. Our comparison of [fixed price vs hourly](https://kleinerauftrag.de/en/costs/fixed-price-vs-hourly/) shows how to combine a fixed build price with hourly maintenance.

## Data protection and API keys

Once customer names or addresses pass through the integration, you are handling personal data. Whoever processes it for you, be it an automation service or the developer while testing, needs a processor contract under [Article 28 GDPR](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679). The UK GDPR contains the same requirement. With services based outside the EU or UK, you also need a legal basis for the international transfer.

During development the programmer needs API keys for both systems. Create dedicated keys you can revoke later instead of handing over your personal ones. Our guide on how to [share passwords with a developer](https://kleinerauftrag.de/en/delivery/share-passwords-with-developer/) explains the practical side.

## Signs it's no longer a small job

Three systems instead of two. Sync in both directions. Thousands of records a day. Or a process where an error costs money straight away, such as wrong stock levels on a live shop. A script written over two evenings won't cut it then. If you want integrations of that size built and run long term, a team like [OnlineBuilders](https://onlinebuilders.biz/solutions/software-development) is one option.

For smaller plans: write down your answers to the seven questions above, add links to both systems' API documentation and two testable [acceptance criteria](https://kleinerauftrag.de/en/scoping/acceptance-criteria-examples/). That package gets you quotes you can compare.

## FAQ

### Is Zapier or Make good enough instead of a custom integration?

For low volumes and simple flows, often yes. You pay a monthly fee instead of development and can adjust things yourself. With many transactions, complex rules or sensitive data, a custom integration usually becomes cheaper and easier to control.

### What's the difference between a webhook and polling?

With a webhook, the source system tells your integration that something happened, such as a new order. With polling, your integration asks every few minutes whether anything is new. Webhooks are faster and use fewer API calls, but not every system offers them.

### Do I need a server for an API integration?

Usually, yes. The code has to run somewhere: your existing web server, a small cloud function or a plugin inside your shop system. Agree upfront who runs and monitors that part.

### Does GDPR apply to an integration?

Yes, as soon as personal data such as customer names or addresses passes through it. Anyone processing that data on your behalf needs a processor contract under Article 28 GDPR, and services outside the EU or UK raise the question of international transfers.

Photo: Dsimic, CC BY-SA 4.0 (https://commons.wikimedia.org/wiki/File:19-inch_rackmount_Ethernet_switches_and_patch_panels.jpg)