If customer AP portals are eating your accounts receivable (AR) team’s week, someone has probably already said it out loud: let us just build an API, wire our systems into the portals, and be done with the manual work. It is a fair thing to want. One integration, invoices flow, the typing stops.
It almost never plays out that way, though, and the reason has little to do with your engineers and everything to do with how customer AP portals are built. So before you scope that build, it helps to know what it really costs, and what an agentic approach does instead.
Definition: API integration to a customer AP portal
A direct software connection between your ERP system and a customer’s AP portal, so invoices, purchase order (PO) data, and statuses pass between them without anyone typing them in.
Why do finance teams reach for an API to solve customer AP portals?
Because from where you sit, an API looks like the permanent fix, and the pain it would end is real. Every day, someone on your AR team logs into Coupa, then Ariba, then Tungsten, then a few portals nobody outside your office has heard of. They retype the same invoice into each one’s format, match it to a PO, and come back later to see whether it cleared or bounced. All those manual processes invite human errors, and every hour spent on them is an hour your team does not get back.
What stings is that you do not control any of it. Your customer picks the portal, and the format of your invoicing data must match, and they can change it whenever they like. To get paid, you play along, one portal at a time.
Stack that across every enterprise customer, and it starts to look like a systems problem. Systems problems have a familiar answer: someone suggests wiring things together with an invoice API integration to end the manual step for good, which is fair. The logic holds right up until you see what is waiting on the other end of that connection.
Why does a customer AP portal integration fall short?
A customer AP portal integration falls short for one structural reason: it treats every portal, and often every customer inside a single portal, as its own custom build. You will not find one endpoint to point at. You are looking at hundreds of them, each with its own fields, business rules, data flows, and update schedule, and any of them can change without a heads-up. That plays out in a few places.
Every portal, and every customer, is its own build
Coupa is not one integration. How one customer sets up Coupa, from the fields they require to the way they match POs, will not match the next customer on the exact same platform. The mapping you built for the first rarely carries over to the second. So the work does not carry. You build for Coupa once per customer who uses it, and again for the next, and again after that.
The connection is not only yours to make
A build like this is not only your project. Every portal must allow the connection, and every customer must test and sign off on their end. So your IT team, an external integration vendor, the portal’s own technical rules, and the customer’s AP team all have to align before a single invoice moves. Any one of them can hold up the timeline, and usually one does.
The maintenance never really stops
Portals change. A customer adds a required field, swaps an approver, or tweaks how it wants POs referenced, and the mapping you shipped quietly stops working. Nothing errors out. The invoice that sailed through last month simply starts bouncing, and it sits there until someone notices the pile. That is the quiet trap of any build: it captures how each portal worked the day you shipped it, and portals do not sit still. Keeping it honest means continuous monitoring and rework with no end date.
A build that keeps up has to become AI
Most plans miss this part. To keep working as portals shift, a build cannot stay a set of static connections. It has to do what an agent does: hold each portal’s and each customer’s current rules in a context layer, and act within the portal through an execution layer that adapts as the screen changes. That is a machine-learning system to build and run, and it is exactly what you were hoping to avoid.
The change that breaks a build is usually the smallest kind: a customer adds or renames a required field, and the mapping stops matching. It rarely happens just once, and each time, an invoice waits until someone fixes it.
What does building an API for the portals actually cost?
More than the number on the vendor quote, the clearest way to see it is as a real project. A while back, an enterprise we worked with set out to automate its portal work. The scale was serious: more than 800 customers using portals, and over 850,000 invoices flowing into them every year. They had even measured the drag. Every customer that forced them onto a portal added 15 to 25 days to their days sales outstanding (DSO), before you counted the daily grind of logins, passwords, shifting data requirements, backup attachments, PO-match research, and chasing exceptions.
So they built. They chose an API solution and put real weight behind it: their own IT team, an outside vendor, and round after round of testing and sign-off with both the portals and their customers. Every invoice still needed its data mapped to each portal and each customer’s rules.
Eighteen months in, they had five customers live. Five. That was a genuine start and also a very clear look at the opportunity cost, because several hundred other portal customers were still waiting.
The build did not fail, exactly. It did what a custom build does: it delivered one carefully mapped connection at a time. That is fine when you have a handful of customers. When 800 are lined up behind the work, one at a time, it is the whole problem. That is the same math behind scaling portal work without adding headcount: the promised cost savings never quite materialize because costs climb with every new customer rather than leveling off.
Why it matters
The build itself is rarely the real cost. The real cost is every customer still waiting while your team wires up the next connection, plus every invoice that stalls when a portal shift breaks the script. Both quietly stretch your DSO.
API vs agentic AI: what does the agent do differently?
An agentic approach skips the custom build entirely. Instead of hard-coding one integration per portal, a self-learning AI agent uses machine learning to read how each customer’s portal works, the way a person would once they logged in, then does the job inside it: submitting each invoice in the right format, keeping it matched to its PO, and following it through to payment. When the portal changes, the agent adjusts automatically, with nothing for you to rewrite.
The difference lies in the places that decide whether AP portal automation actually holds up:
This is the model behind AI-powered portal automation: the agent works from the portal’s current rules, so a changed field becomes something it handles instead of something that snaps the pipe. It is also where the market is heading. More and more of the systems businesses depend on sit behind logins with no real API, and for those, the only thing that works is an agent that logs in and does the job the way your team does.
Compared with the 18 months it took to reach five customers, an agentic setup goes live in about 48 hours. It is self-serve, with no IT project required: you add your team and portal logins, upload a payment report, and the agents start working.
When does an API still make sense, and when does it not?
Sometimes a build really is the right call, and it is worth being straight about when. If you have a small, steady set of customers whose portals offer a genuine API, whose requirements barely move, and you have engineers with time to own each connection for the long term, a direct build can pay off and hum along for years.
It stops making sense as the list grows. Add portal customers often, watch their requirements drift, or run into the many portals with no real API at all, and the build never catches up. The invoices stacking up behind it start costing you more in DSO than the integration ever saves. Connecting your ERP to customer portals is worth doing well, no matter which camp you are in. The honest question is whether you want to build and babysit that connection to every portal yourself.
What should you ask before building an API for the portals?
Before anyone commits engineering time, get honest answers to a handful of questions. If they point at a moving target, the build is going to fight you the whole way.
- How many of our customers’ portals actually offer a real API, and how many will always need manual work?
- How different is one customer’s setup from the next inside the same portal, and does a single build carry over?
- Who owns the fix on the day a portal changes, and how fast can they clear a rejection?
- What is each month of delay costing us in DSO while the build crawls through customers one at a time?
- Are we solving this for the five customers in front of us, or the 200 coming up behind them?
How Monto handles the portal work
This is the problem Monto was built for. Monto is the autonomous co-worker that gets you paid by your enterprise customers, from your system all the way to the cash. It puts a self-learning AI agent on every customer relationship, and each agent learns the exact workflow of the AP portals your customers use, Coupa, Ariba, Tungsten, Tipalti, and 500 or so others, then carries every invoice from your ERP through to payment.
You do not build a per-portal integration, nor do you babysit one when a portal shifts. The agent submits each invoice in the portal’s format, keeps it matched to its PO, and posts a status update for every invoice across every portal in a single AI-powered dashboard, so your team finally gets real-time visibility and clean audit trails without logging in.
You can build a connection to every portal and keep it alive forever, or you can put an agent on every customer and skip the build. That second path is the one that gets you paid through your customers’ AP portals without ever running an integration project.
Stop building integrations. Start getting paid.
Put an agent on every customer AP portal and skip the build.
Book a Monto demo →FAQ
Can you connect to customer AP portals with an API?
Sometimes, yes. A few portals offer a genuine API, and for a small, stable set of customers, a direct build can work fine. But many customer AP portals have no usable API at all and only accept invoices through their own screens, which is why an API-only plan tends to reach just a slice of your customers.
Why do API integrations to AP portals break so often?
Because every portal is a moving target. A customer renames a required field, changes how POs are referenced, or swaps an approver, and an integration built to last month’s rules starts rejecting invoices until someone rebuilds the mapping.
Is agentic AI just another integration?
Not really. A customer portal integration is a fixed connection you code once and maintain forever. An agentic AI approach places a self-learning agent on each customer, following the portal’s live rules and performing work within the portal, adjusting as things change rather than breaking.
How long does it take to automate customer AP portals with Monto?
About 48 hours for most teams. Setup is self-serve and needs no IT: add your team and your portal logins, upload a payment report, and Monto’s agents start working. With no per-portal build to ship, nothing holds you up.
Should we build or buy portal automation?
It comes down to a few things: how many portal customers you have, how often their requirements change, how many of their portals lack an API, and whether your team can maintain it all indefinitely. A small, stable, API-friendly set can be worth building yourself. On a growing list across many changing portals, buying usually wins because the buy side does the adapting for you.