For SaaS & vertical platforms

Your customers are companies. They run their operations inside your platform — invoicing, payroll, inventory, bookings, dispatch — which means you already hold the operating data that says when one of them is short of working capital and good for it. Embedded finance turns that signal into a product line: a “Get funding” button in the exact screen where the need shows up. Credicorp supplies the balance sheet and the regulated-adjacent lending machinery; you supply the distribution, the context and the brand.

Why embed financing

Offering credit inside the workflow is the highest-converting place to offer it, because it lands at the moment of need with the data already attached. For a vertical SaaS business it does three things at once: it deepens the product (one more reason customers can’t leave), it lifts the numbers your customers care about (cash in hand to buy stock, take the big order, make payroll), and it opens a margin line that scales with your base rather than your headcount.

• Native, not a redirect. Embed a co-branded hosted journey, or white-label it pixel-for-pixel so it reads as your own feature.
• You keep the customer. Credicorp is the lender of record; you remain the platform the customer logs into every day.
• Data-rich underwriting. The operating context you already hold — turnover, payment history, seasonality — can be passed through to sharpen the decision.
• Outcome-aligned economics. You earn when a loan funds, and there’s nothing to pay while you build and test.

Who this is for

Any platform whose users are UK incorporated businesses and whose product touches money or operations: vertical SaaS (field service, hospitality, e-commerce ops, logistics, clinics), B2B fintech and spend-management tools, ERP and accounting platforms, procurement and supply-chain software, and payment facilitators looking to extend into credit. If your customers are limited companies or LLPs that occasionally need short-term working capital, the fit is direct.

How it works

You build once against the same Apply, Decisioning and Payments APIs that power Credicorp’s own product, and the same sandbox and SDKs. A typical embedded flow is four steps:

Creating an application from your backend is a single authenticated call. Pass the borrower’s company number, the amount in pence and your own reference; everything else — affordability, pricing, the decision — happens server-side at Credicorp:

curl -s https://api.credicorp.co.uk/v1/applications \
  -H "Authorization: Bearer $TOKEN" \
  -H "Idempotency-Key: app-acct_8841-ord_5512" \
  -d '{
    "company_number": "12345678",
    "amount_pence": 2500000,
    "term_months": 12,
    "purpose": "working_capital",
    "platform": {
      "partner_reference": "acct_8841",
      "context": { "trailing_12m_turnover_pence": 84000000, "tenure_months": 29 }
    }
  }'

HTTP/1.1 201 Created
{
  "id": "app_3f7aQ9",
  "object": "application",
  "status": "approved",
  "offer": { "amount_pence": 2500000, "term_months": 12, "total_repayable_pence": 2710000 },
  "handoff_url": "https://apply.credicorp.co.uk/o/3f7a…",
  "partner_reference": "acct_8841"
}

From there you either render the offer in your own UI or send the borrower to handoff_url, and you listen for decision.completed, loan.funded and the repayment events on Webhooks. The end-to-end build is documented in Integrate lending.

The commercial model

Embedded finance pays you to distribute. When a loan you originate funds, you receive a share of the net lending margin Credicorp earns over the life of that loan, settled monthly — the same revenue-share mechanism described on the Pricing page. You build and test on the free sandbox; nothing is billed until real money moves. The figures below are illustrative only — your actual rate is agreed per partner and depends on volume, who owns the customer relationship and how much of the journey and risk presentation you operate.

Brand & control

You choose how much of the journey you own. The co-branded hosted journey is the fastest path and keeps all borrower PII off your servers — Credicorp renders the regulated-adjacent screens, you keep the customer in your shell. White-label hands you every pixel through the API, which means you also take on the identity, consent and accessibility obligations on those screens. Most platforms launch hosted to get live quickly, then graduate to white-label once embedded finance is proven in their base. Both run on the same APIs, so moving between them is a configuration change, not a rebuild.

Getting started

You can build the entire integration before any commercial paperwork is signed — the sandbox is free and mirrors production endpoint-for-endpoint. The Quickstart takes you from zero to a funded sandbox application in about ten minutes.