Pricing and ROI: $14,000, once. You own it.
One flat price for the whole build, no per-invoice fee and no subscription bolted on top of it. This page shows exactly what the number includes, what it does not, how it stacks up against whatever else you are already comparing it to, and how to model your own payback, with the formula shown and no number promised.
One flat number. Here is everything it buys.
The price for the AI Accounts Payable Automation build is $14,000, paid once. Not a "starting at" figure, and not a number that grows once discovery turns up something inconvenient about your invoice formats or your vendor list. It is the price for the whole engagement, from the first discovery conversation through a 30-day stabilization period after your team has cut over to running the agent on live invoices.
That is a deliberate choice, not a marketing line. A per-invoice platform prices its risk into a metered fee that rises with your volume forever. An outsourced AP shop prices its risk into an hourly or per-transaction rate that never goes away either. Both of those models mean the vendor gets paid more the longer your problem stays partly unsolved. I priced the risk once, up front, into a fixed number, because an open-ended engagement that grows as the invoices get weirder or the exceptions get gnarlier is exactly the kind of vendor relationship this build exists to replace.
Here is what the flat fee covers, item by item. Nothing on this list is a phase-two upsell; it is all inside the $14,000.
The boundary is exact: discovery starts the clock, stabilization ends it, and everything in between is included regardless of how many invoice formats turn up or how many exception categories the taxonomy grows to once we look at your real history. If your invoice reality turns out messier than a typical mid-market operation, that risk is priced into the $14,000 already, not billed back to you afterward as a change order.
What the $14,000 does not include
Two costs sit outside the flat fee, and I would rather you know them now than find them later in a footnote. The first is your own API and hosting spend: the usage-based cost of the document-processing and language-model calls the pipeline makes, plus wherever you choose to host it. For a mid-market invoice volume that typically runs $200 to $600 a month, billed to your own cloud and model-provider accounts, visible to you line by line. I do not mark it up, because it is not mine to mark up; it runs on infrastructure you control.
Concretely, that spend covers three things: the document-AI service that handles OCR and layout (Amazon Textract or Azure AI Document Intelligence, for example), the language-model API calls used for extraction and match reasoning, and hosting for the database that holds your vendor and historical-coding context. All three scale with your invoice volume, which is exactly why they are metered separately from the fixed build price instead of folded into it and guessed at up front.
The second cost is optional: a $1,000-a-month monitoring retainer, where I watch the eval dashboard, tune extraction on the invoice formats that drift, and handle vendor-master or accounting-system changes on your behalf. You can cancel it anytime, and nothing about the system you own requires it to keep running. Plenty of clients set up their own re-evaluation schedule instead and skip the retainer entirely; the regression suite and the golden dataset are yours to re-run whenever you want.
Neither of these is a lever I use to inflate the number after the fact. The build, the code, and the eval harness are yours whether or not you keep the retainer, and payment approval never moves outside your existing chain regardless of who is watching the dashboard. That boundary is enforced in code, not policy, and it is covered in full on the Security & controls page.
Against the alternatives
Before you book a call, put this next to whatever else you are evaluating. Four honest columns: this build, a per-invoice SaaS platform, a BPO or outsourced AP shop, and hiring a freelancer or contractor to keep doing the work by hand.
| This build | Per-invoice platform | BPO outsourcing | Freelancer | |
|---|---|---|---|---|
| Cost | $14,000 once, plus your own API and hosting spend, typically $200–$600/mo | Per-invoice or per-seat fee, compounding with volume, forever | Per-invoice fee or monthly retainer, forever, scaling with your volume | Hourly or salaried, ongoing, plus management overhead |
| Pricing public? | Yes, on this page | Usually behind a 'request a demo' form | Rarely; negotiated per client, per contract | Depends on the person, but the meter runs regardless |
| Who owns it | You: the code, the evals, the golden dataset | The vendor | The BPO; the process knowledge leaves if you leave | No one in particular; the person is the system |
| Proof of touchless rate | A parallel run plus an eval suite you keep and can re-run | Their marketing number, measured on their customers, not yours | An SLA on paper, rarely independently audited | Whatever they report you, unverified |
| Payment authority | None. Enforced in code, not configurable on | Varies; some platforms do initiate payment | Sometimes, depending on the contract | Depends on the access you choose to grant |
"Proof of touchless rate" is the row worth sitting with. Every other option on this table asks you to trust a claim someone else measured on someone else's invoices. This build hands you the harness that tests it, on your invoices, before you commit to running it live, and the dashboard that keeps measuring it after cutover. That is covered in full on The proof, and it is the reason the price on this page can stay public while most of the alternatives keep theirs behind a sales call.
Model your own payback. I will not hand you a fake number.
Every AP-automation vendor shows an ROI slide with a big number on it. I am not going to promise you one, because the honest answer depends entirely on your invoice volume, your PO discipline, and your vendor mix, none of which I know before we talk. What I can give you is the real cost data behind the math and the formula itself, so you can plug in your own numbers.
The industry numbers are not in dispute. 77% of organizations still key invoices by hand (IFOL AP Automation Trends 2026, with SAP Concur), 63% of AP teams spend 10 or more hours a week on invoice processing (IFOL, 2025), and a manually processed invoice runs $12 to $30 in fully loaded labor cost, against roughly $3 once it is automated (Datrose / PLANERGY, 2025–2026). That gap, $9 to $27 saved per invoice that goes touchless, is where any real ROI comes from. Nothing else on this page invents a number; those three are cited, and they are the same ones on the overview page.
What I will not do is multiply that gap by your invoice count and hand you a headline figure, because the variable that actually determines your result, the touchless rate you achieve, is not something I can know in advance. It depends on how consistently your purchase orders get raised, how messy your vendor master is, and how much the exception queue teaches you to fix upstream in the first few weeks. That number is measured, not promised: the parallel run in week five runs the agent against your live invoices before you cut over, and it is the same run described on The proof.
So here is the formula instead. Plug in your own figures once you have them, or use it as a sanity check on any vendor's slide, including mine.
× (your actual touchless rate)
× (cost per manual invoice, $12–$30, minus cost per automated invoice, about $3)
Payback in months = $14,000 ÷ monthly value
A worked example, purely illustrative: at 2,000 invoices a month, a 70% touchless rate, and a $20 manual cost against a $3 automated cost, the formula gives 2,000 × 0.70 × ($20 − $3) = $23,800 a month, or roughly $285,600 a year, in labor cost alone. That would put payback at well under a month. I have no idea whether 70% is realistic for your operation; it might be higher, it might be lower until your PO discipline tightens. Run the same arithmetic with your own invoice count and whatever touchless rate the parallel run actually measures, and you will have a payback number that means something because it is yours, not a number lifted from a vendor deck.
The formula also only captures the hard-dollar side. It leaves out fewer late-payment fees and the early-pay discounts you can actually capture when invoices move faster, a faster month-end close because coding is not backed up in a queue, and the fact that your AP team's time shifts from re-keying data to the judgment calls the exception queue actually needs, which is usually the reason the role gets easier to staff, not just cheaper. None of that is quantified here on purpose; if I cannot show you the receipt for a number, I would rather leave it out than dress up a guess as a projection.
One more honesty check: the rate is not static from day one. Expect it lower in the first weeks after cutover, while the exception queue is still surfacing the PO gaps and vendor-master problems nobody had cleaned up before, and higher once your team fixes what the queue keeps flagging. Model your payback on the rate the parallel run measures at cutover, and treat anything higher after the 30-day stabilization period as upside, not the baseline you plan around.
The accounting-firm math changes everything
If you run AP for multiple clients as an accounting or BPO firm, the flat-price model compounds in your favor in a way it does not for a single in-house finance team. You are not paying $14,000 once and being done with it; you are paying it once for the build pattern, then extending it to each additional client at a public follow-on price, most of which covers connecting to that client's own instance of QuickBooks Online, Xero, or NetSuite. One accounting system per build is what keeps any single engagement's price fixed; a second system or a multi-entity setup is a follow-on with its own public price, detailed on the Integrations page. Each new client also gets its own golden dataset and its own eval-harness run against its own invoice history, so the touchless rate you can show that client is measured on their invoices, not borrowed from someone else's.
Compare that to what a per-invoice platform charges a firm: a per-entity or per-seat fee that recurs for every client, forever, with the platform's margin baked into every invoice processed on that client's behalf. Here, the gap between what a client would otherwise pay a platform and what it actually costs you to extend the build to them is margin you keep. It is the strongest economics on this page. If that is your situation, say so on the call; the conversation and the follow-on pricing are different for firms, and better.
Each client engagement stays isolated: separate vendor data, a separate golden dataset, and separate eval results, so one client's invoice quirks never leak into another's coding patterns. And because the build pattern is proven on the first client, subsequent engagements tend to move faster through discovery, the part of the five weeks that took longest the first time, mapping the invoice flow and fixing tolerances in writing, is largely a known quantity by the third or fourth client.
The number only means something because of what proves it.
You now have the price, exactly what it includes, what it does not, how it compares to the alternatives, and the formula to model your own payback. The one thing left to verify is whether the touchless rate holds on your invoices, and that is measured before you commit to anything, not promised on a call.