
API integration cost: build vs buy, priced on one ledger

Summarise the blog with AI
Last verified: 2026-11-17
Key takeaways
- A wage is not an hourly cost: BLS data for June 2026 implies a loaded rate of about 1.43 times the wage, before equipment and overhead.
- A working webhook handler is not a finished one: production adds signature checks, duplicate handling, retries, ordering and fast acknowledgement.
- Upkeep recurs: Stripe ships major releases twice a year that can contain breaking changes, and upkeep multiplies by every integration you run.
- This guide covers four billing units that integration platforms use, connection, task, execution, or edition plus credits, and the unit a vendor meters decides what grows your bill.
- Buying leaves mapping, coverage gaps, missing fields, onboarding and monitoring on your roadmap.
- Over three years, the winner depends on which input grows faster: your integration count or the vendor's billing unit.
Set an engineer's salary against a vendor's sticker price and the build-versus-buy comparison looks finished. Neither number is the cost.
Building costs loaded engineering hours for the first version, the production hardening and the yearly upkeep, multiplied by every integration you ship. Buying costs the vendor's billing unit times whatever grows that unit, plus the integration work you still own. Put both on a three-year ledger and one question decides it: which side grows as your customer count does?
The usual starting point for the build side is the BLS Occupational Outlook Handbook, which reports a median annual wage for software developers of $135,980 in May 2025. That is a wage, and the gap between a wage and a cost is where the first budget error lives.
Why a developer's wage understates what an hour costs
A wage is what an employee is paid. A loaded rate is what the employer pays for that hour to be worked, benefits included.
BLS measures the gap in its Employer Costs for Employee Compensation release. In June 2026, private-industry employer compensation costs averaged $46.89 per hour worked. Wages and salaries were $32.82 of that (70.0%), and benefits were $14.07 (30.0%).
Divide any wage by 0.70 and you get the loading, about 1.43 times. That is arithmetic on a BLS figure, not a BLS estimate for engineers. It is an all-private-industry average, and it covers compensation only. Equipment, software seats, office and management overhead sit outside it.
Apply it to the developer median. $135,980 over 2,080 hours is about $65 an hour, and loaded at 1.43 it is about $93 an hour. Both are derived figures, and $93 is a compensation-only rate, so add whatever overhead your finance team counts.
A defensible rate prices an hour. It says nothing about how many hours a production integration takes, which is where the next error hides.
Where the hours in an integration build actually go
An estimate that stops at a handler that works in a demo leaves out five production concerns, and each one is engineering time.
Webhooks make the point well. Stripe documents its delivery behaviour precisely, and the Standard Webhooks specification, an open spec, defines what a signed delivery carries: webhook-id, webhook-timestamp and webhook-signature headers, with the signature an HMAC-SHA256 over {id}.{timestamp}.{body}.
| Concern | What the source says | What you must build | Why it adds hours |
|---|---|---|---|
| Signature verification | Standard Webhooks: HMAC-SHA256 over id, timestamp and body, carried in headers | Recompute the HMAC on the raw body, reject mismatches | Re-serialized JSON changes the bytes, so the check fails in ways that are slow to debug |
| Duplicate delivery | Stripe's docs: an endpoint may receive the same event more than once | A record of processed event IDs, idempotent side effects | A dedup store, plus handlers safe to run twice |
| Retries and the three-day window | Stripe, live mode: delivery attempts for up to three days with exponential backoff | Tolerate late arrivals; a recovery path for events that exhaust retries | Outages and backlog replays become your problem |
| Out-of-order events | Stripe does not guarantee delivery in the order events were generated | Apply by current state, not arrival order | Logic for "updated" landing before "created" |
| Fast acknowledgement | Stripe advises returning a 2xx quickly, before complex logic | Queue the event, acknowledge, process in a worker | A second pipeline with its own failure handling |
Read down the third column and a pattern shows. Stripe promises delivery attempts, so exactly-once and in-order processing are guarantees your code has to supply.
Some providers carry part of that load for you. Bindbee's version 2 webhooks follow the Standard Webhooks spec, and every event carries an id that stays the same on each retry, which is your deduplication key, plus a sequence number per connector for putting events in order. For what the signature check involves in depth, see Bindbee's guide to how HMAC secures webhooks.
Beyond the webhook work, an estimate should also scope whichever of these lines your source systems require:
- authentication and credential renewal, including relinks when an employer's OAuth grant expires
- employer-side setup before the first call works, such as a service user with the right permissions or ADP's certificate request
- pagination
- rate-limit handling, where the source system's own limits, usually far tighter than yours, set how long a full employee sync takes
- field mapping, including effective-dated records where one employee carries several employment rows over time
- per-customer configuration
Priced at the loaded rate, those are the first-version and hardening rows of the ledger. They also recur, because the system at the other end does not stand still.
What an integration keeps costing after it ships
Upkeep is a recurring cost because the systems you integrate with change on their own schedules.
Stripe's API versioning documentation shows the schedule at its most orderly. Since the 2024-09-30.acacia release, Stripe ships monthly API versions with no breaking changes, and twice a year a new major release starts with a version that does contain breaking changes. Upgrading to it can require changes to your integration, so even a single integration costs hours on a calendar.
HR systems change on their own schedules too, and less predictably. An employer's OAuth grant expires and their admin has to relink. A customer's admin renames a custom field. A payroll vendor ships a second API generation alongside the first. Bindbee's comparison of ADP Workforce Now and the next-generation API covers how two API generations from one vendor diverge.
Budget upkeep against five drivers:
- scheduled breaking releases from the systems you integrate with
- credential expiry and re-authorization
- schema and field changes
- customer-specific configuration drift
- monitoring and incident response
Every driver is per integration, so upkeep multiplies: upkeep hours × loaded rate × number of integrations, every year. Take the upkeep hours from the ticket and incident history of integrations you already run.
The build side is now a recurring per-integration cost. The buy side has to be read the same way, as a cost that grows, and what it grows with depends on how the vendor meters.
How integration platforms charge, and which billing unit grows with you
Integration platforms typically charge on a connected customer account, a task, a workflow execution, or a platform edition plus usage credits, and the unit, not the plan name, decides what your bill grows with: customers, activity, runs, or a platform commitment.
The table classifies pricing by what is counted. The properties are typical of each category, and individual vendors vary.
| Billing unit | What is counted | What makes the bill grow | Fits customer-facing integrations when | Question to ask the vendor |
|---|---|---|---|---|
| Per connection | A connected customer account; vendors differ on which states count, and some count idle connections | Customer count | You can forecast connected accounts | Which connection states are billable? |
| Per task or action | Each qualifying successful action step; some step types use more than one unit | Event volume × steps per workflow | Activity per customer is low and steady | What counts as a task, and what do overages cost? |
| Per workflow execution | One complete run, however many steps it has | Number of runs | Workflows are long and run counts are predictable | What triggers an execution? |
| Platform edition plus credits | A fixed edition fee plus metered credits; add-ons billed separately; may require a sales quote | Credit burn and add-ons | You can model credit use before signing | What consumes credits, and which add-ons do I need? |
In the per-connection model, the bill typically follows your customer accounts directly. Tasks, executions and credits typically follow activity, so a customer who syncs more often can cost more under any of them even when your customer count is flat.
The category matters before the vendor does. Workflow tools, ETL and unified APIs are different products with different meters. Bindbee's explainer on how unified APIs, workflow automation and ETL differ covers the split.
Bindbee, a unified API, bills per connected customer. Every integration is included at every tier and syncs aren't metered, so in the table above it sits in the per-connection row: the bill follows your customer count, not their activity or how many systems you add. Whichever vendor you evaluate, Bindbee included, ask which connection states are billable.
What integration work is still yours after you buy
Buying moves connector work to the vendor. It leaves the work that connects the vendor's output to your product.
Put these lines in the buy column:
- mapping the vendor's data model into your own
- coverage gaps, where a system or model is not supported
- fields the unified model lacks
- customer onboarding, meaning the connection flow and support
- monitoring connections and sync failures
A vendor can shrink two of those lines, coverage doubt and missing fields, by publishing the detail. Bindbee's Model Availability Matrix marks each model, per integration, as Available, Beta or not available. Coverage varies by integration, so check the matrix for your systems and models rather than assuming any model works on any system.
For a field the unified model lacks, Bindbee offers three routes:
include_raw_data=truereturns the upstream payload next to each record, so you can find the field you're missing- Custom Fields then map that field onto the unified model through a JMESPath expression, per integration or per connector
- Passthrough forwards a raw request to the source system's own API using the connector's existing credentials, for a field the payload doesn't carry at all
The custom fields, raw data and passthrough guide shows each in practice. None of this makes mapping, onboarding or monitoring disappear. They stay on your roadmap whichever vendor you choose, and they belong in the ledger as hours.
Where building beats buying, and where it flips
The comparison flips on which input grows faster: your integration count, which drives the per-integration lines in the ledger, or the vendor's billing unit, which drives the subscription. Fill in the ledger below for each approach.
Y0 is the period before go-live, and the three years in service are Y1 through Y3. Enter each line in the period where you incur it, so a subscription that bills from signature, or hosting stood up before launch, goes in Y0. Each side's total is Y0 plus Y1 through Y3. Enter a pre-launch cost once: onboarding hours already counted in implementation do not repeat as remaining work.
| Symbol | Meaning |
|---|---|
| R | Your loaded hourly rate, from the first section |
| N | Integrations live that year |
| new | Integrations added that year |
| U | Upkeep hours per integration per year |
| C, h | Customers added that year, and setup hours per new customer (build side) |
| H | Your hour estimate. Where a cell multiplies H by N or by "new", H is hours per integration; where a cell reads H × R alone, H is the total hours for that line across all your integrations |
| S | The annual subscription your actual quote produces at that year's projected volume: fixed edition or tier fees, which stay put as volume moves, plus metered charges (connections, tasks, executions or credits), overages and add-ons, which move with it. Use the quote's own arithmetic |
| Line item | Build Y0 | Build Y1 | Build Y2 | Build Y3 | Buy Y0 | Buy Y1 | Buy Y2 | Buy Y3 |
|---|---|---|---|---|---|---|---|---|
| Initial build or implementation | H × R × N | H × R × new | H × R × new | H × R × new | H × R | H × R × new | H × R × new | H × R × new |
| Production hardening | H × R × N | H × R × new | H × R × new | H × R × new | H × R, if yours | H × R × new, if yours | H × R × new, if yours | H × R × new, if yours |
| Upkeep × integrations | U × R × N, if incurred | U × R × N | U × R × N | U × R × N | in remaining work | in remaining work | in remaining work | in remaining work |
| Per-customer setup | C × h × R | C × h × R | C × h × R | C × h × R | in remaining work | in remaining work | in remaining work | in remaining work |
| Hosting (build) or subscription from your quote (buy) | hosting, if incurred | hosting | hosting | hosting | S, if incurred | S | S | S |
| Remaining work | n/a | n/a | n/a | n/a | H × R, if incurred | H × R | H × R | H × R |
| Time to first production data | your estimate | n/a | n/a | n/a | vendor's figure | n/a | n/a | n/a |
The last row is a date, but delay is a cost on a customer-facing roadmap. For one vendor's figure: Newfront went from contract to first production sync with Bindbee in about 48 hours. Systems that need an employer-side approval first, such as ADP's certificate route, take longer.
Here is the ledger filled with invented inputs, every one an assumption to replace. R is $90 (the derived $93, rounded down), with four integrations live at go-live and none added later. Build, per integration: 160 hours to ship and 80 to harden in Y0, then 40 hours a year of upkeep, with hosting at zero.
In the example, every recurring charge starts at go-live, so Y0 carries one-time work only. That is the example's choice; the template doesn't require it.
The example also leaves per-customer setup at zero so the other lines stay readable. Don't do that with your own numbers. Bindbee's ROI calculator assumes 8 hours of developer time for a simple additional customer configuration and 16 for a complex one, so a build side adding 50 customers a year at 8 hours carries another $36,000 a year at $90.
The buy side uses 120 hours of implementation across all four integrations in Y0 and no hardening hours, on the assumption that the vendor carries connector-level work. It then has 60 hours a year of remaining work, and S is $36,000 in Y1 at today's unit volume. In the growth scenario, unit volume rises 50% a year after Y1, so S in Y2 is 1.5 times its Y1 value and S in Y3 is 2.25 times.
The example assumes a linear tariff: S moves one-for-one with unit volume. Real quotes can bend that line. A fixed fee dilutes growth, a tier boundary steps it, and an overage rule can steepen it, so an invoice can grow slower or faster than the volume behind it. That is why the template takes S from your quote, not from price × units.
Each cell below is the ledger arithmetic: Y0 build is 240 hours × $90 × 4, and Y1 buy is $36,000 plus 60 hours × $90.
| Scenario, four integrations | Y0 | Y1 | Y2 | Y3 | Total, Y0 to Y3 |
|---|---|---|---|---|---|
| Build | $86,400 | $14,400 | $14,400 | $14,400 | $129,600 |
| Buy, unit volume flat | $10,800 | $41,400 | $41,400 | $41,400 | $135,000 |
| Buy, unit volume up 50% a year after Y1, linear tariff | $10,800 | $41,400 | $59,400 | $86,400 | $198,000 |
All three rows cover the same four integrations, so they are the comparison. With the same hours and the same rate, the buy total moves by $63,000 on one assumption: how fast the billing unit grows on a linear tariff. If that unit is connected customers, the per-customer setup line grows on the build side too, so price it before comparing the two growth rows. The build total moves on a different input: integration count, through the lines that carry N.
That second input can be shown head to head. Keep the same hours and rate, add four integrations in Y1 and four more in Y2, so 12 are live from Y2, and hold customer count flat. Each new build integration costs 240 hours to ship and harden, and upkeep covers every live integration. Each new buy integration costs 30 hours of implementation (the Y0 rate of 120 hours across four), remaining work stays at 60 hours a year, and S stays at $36,000 because the example's quote prices connected customers, not integrations.
| Scenario, 4 to 8 to 12 integrations, customers flat | Y0 | Y1 | Y2 | Y3 | Total, Y0 to Y3 |
|---|---|---|---|---|---|
| Build | $86,400 | $115,200 | $129,600 | $43,200 | $374,400 |
| Buy | $10,800 | $52,200 | $52,200 | $41,400 | $156,600 |
Build Y1 is 4 new × 240 hours × $90 plus 8 live × 40 hours × $90. Buy Y1 is $36,000 plus 60 hours × $90 plus 4 new × 30 hours × $90. Here the order flips, because the build lines carry N and this quote's S does not. If your quote prices per integration, S grows with N too and the gap narrows; if your mapping and monitoring work scales with integrations, raise the remaining-work hours.
The flip conditions follow from which input grows. Building tends to win when:
- the integrations you need are few and stay few
- the vendor's billing unit grows faster than your customers
- most of the logic is specific to your product
Buying tends to win when:
- your integration count keeps rising, and the build lines that carry N rise with it
- the billing unit grows slower than your customers, or on an input you control
- upstream change is frequent and you would carry the upkeep on each source
There is a third option. A hybrid buys the shared plumbing (authentication, pagination, normalizing each source's fields) and builds the product logic that differentiates you. It needs no new template: fill the buy columns for the plumbing, the build columns for the logic, and give every cost line exactly one owner.
Allocate the hybrid row by row:
- Initial implementation: the buy-side hours for the connectors you purchase, plus build hours for product logic only, both at R.
- Hardening: hours only for code you own, such as how your product handles what the vendor sends, with connector-level hardening assumed to sit with the vendor until the contract says otherwise.
- Upkeep: U counts only the logic you own, and upkeep on vendor-owned connector code stays off your ledger beyond S.
- Subscription: S from the quote, covering only the connectors you buy.
- Remaining work: mapping, onboarding and monitoring as hours, entered once.
Double counting happens when one driver shows up in two rows. Credential renewal, say, can appear in U and again in remaining work. Assign each driver to whoever owns the code it touches, and enter it once.
For the decision beyond cost, see the build vs buy decision framework, and for how the vendors compare, see the top API integration companies for 2026. To run your own inputs through a model, use Bindbee's ROI calculator. We build the integrations, and you build the product.
FAQ
Why does per-task automation get expensive?
Per-task pricing gets expensive because every qualifying action step is billed, so cost grows with event volume multiplied by steps per workflow, not with your customer count. Some step types consume more than one task, and overage rates can apply once you pass your plan's allowance.
What counts as a task in task-based pricing?
A task is typically a successful action step in a workflow. Triggers, logic steps and failed steps are often not counted, but this varies by vendor, so read the vendor's own definition before modelling volume.
Is a unified API cheaper than building integrations in-house?
It depends on which input grows faster. In the worked example above, building four integrations that never change costs less over three years ($129,600 against $135,000). Adding eight more over two years flips it ($374,400 against $156,600) under a quote that prices connected customers rather than integrations. Put your own hours, rate and quote through the ledger before deciding.
Can you self-host an integration platform to cut cost?
Self-hosting trades the subscription for infrastructure, upgrades and on-call work, so it moves cost back onto the build-side lines rather than removing it. Those are the upkeep drivers above: credential renewal, change handling, monitoring and incident response now sit with your team.






