Reconciliation

In real card programs, transactions rarely arrive cleanly or all at once. Authorizations, captures, reversals, fees, and settlements can appear hours or days apart, often in different formats and files. Without a robust reconciliation layer, ledgers drift, balances become unreliable, and operations teams are forced into manual cleanup.

Canopy’s reconciliation service is designed to solve this problem at scale.

At a high level, Canopy:

Ingests transaction data from external processors
Normalizes it into a consistent internal format
Compares it against Canopy’s ledger
Identifies mismatches
Optionally corrects them through controlled, auditable backdated actions

The result is a ledger you can trust — even when upstream systems are imperfect.

Canopy’s Role: System of Record, Not Issuer

Before diving into the mechanics, it’s important to clarify Canopy’s position in the ecosystem.

Canopy does not replace your issuer processor. Canopy enables innovative handling of charges based on similar data that your issuer processor captures (e.g. better rates for certain MCC codes; offer “pay over time” for transactions of certain types and within a given amount range)

Canopy is about building / tailoring the credit you want to offer borrowers by leveraging data from your issuer processor.

What Canopy does provide is:

A definitive system of record for balances and credit state
A reconciliation layer that absorbs issuer complexity
A servicing and audit foundation that keeps statements, balances, and reporting consistent

This division of responsibility allows Canopy to complement issuers rather than compete with them — and to support credit products that issuers alone struggle to manage.

Why Reconciliation Matters

The Reality of Card Programs

In production environments:

Authorizations may never settle
Settlements may post days later
Amounts may change (tips, partial captures, incremental auths)
Reversals may happen asynchronously
Files may arrive late, duplicated, or out of order

Issuer processors do not solve these problems for you. They expose them.

Without reconciliation:

Ledgers diverge from reality
Statements become unreliable
Ops teams manually investigate issues
Trust erodes with partners and acquirers

With reconciliation:

Discrepancies are detected early
Corrections are applied consistently
Balances remain auditable
Operations scale without heroics

How Canopy Reconciliation Works (Conceptually)

Canopy’s reconciliation flow follows a simple but powerful pattern.

1. External Transaction Ingestion

When Canopy integrates with an issuer processor, we retrieve transaction reports. These reports may be delivered via SFTP, object storage, or APIs, depending on the provider.

The raw files are stored intact for traceability and audit purposes.

2. Normalization into a Generic Reconciliation Format

There is no industry-wide reconciliation file standard. Every processor exports data differently.

Canopy solves this by converting all incoming files into a canonical reconciliation format that captures the essentials:

Transaction identifiers (processor, network, internal)
Transaction type (authorization, capture, reversal, fee, etc.)
Amounts and currency
Key dates (authorization, clearing, settlement)
Status and lifecycle state

This normalization step allows Canopy to reconcile any supported processor using the same downstream logic.

3. Diffing & Exception Detection

The reconciliation engine compares external data with Canopy’s internal ledger and identifies differences.

Common exception categories include:

Missing internal transactions External activity exists, but no corresponding ledger entry was found.
Amount mismatches The transaction exists on both sides, but the amounts differ (partial capture, tip, adjustment).
Status mismatches One side shows a reversal or settlement that the other does not.
Duplicate matches Multiple internal records map to a single external transaction.

Each exception is classified, stored, and made visible for review.

4. Resolution & Backdated Corrections

For certain exception types, Canopy can automatically resolve discrepancies through backdated transactions, when enabled.

Examples include:

Creating a missing draw when an external authorization exists
Backdating an authorization so balances reflect historical reality
Resolving timing differences without manual intervention

All corrective actions are:

Explicit
Traceable
Auditable

Nothing is silently rewritten.

Backdated Transactions: Why They Exist

Backdated transactions are not a workaround — they are a necessity.

Issuers often post transactions late. When this happens, balances, statements, and historical reports must reflect when the transaction actually occurred, not when it was discovered.

Canopy’s backdating support allows:

Historical balances to remain correct
Interest and fees to calculate accurately
Statements to remain consistent
Audits to pass cleanly

This capability is foundational for any serious credit product.

What Clients Get

By using Canopy’s reconciliation service, clients gain:

Ledger integrity Your balances reflect reality, even when upstream data is messy.
Operational visibility Clear exception categories instead of vague mismatches.
Reduced manual work Fewer spreadsheets, fewer fire drills.
Audit readiness Raw files, reconciliation results, and corrective actions are all retained.
Issuer flexibility Canopy absorbs processor quirks so you don’t have to rebuild your core for each partner.

Supported & Extensible

Canopy’s reconciliation architecture is designed to support multiple processors and formats.

Initial implementations focus on Stripe-based transaction exports, with the framework built to extend to:

Issuer processor reconciliation files
Clearing and settlement reports
Fee and adjustment feeds

As new providers are added, they plug into the same normalization and diffing pipeline.

In Summary

Reconciliation is what separates demo-ready platforms from production-ready ones.

Canopy does not try to replace issuers. Instead, we complete them — by owning the ledger, reconciliation, and servicing layer that real credit programs depend on.

With Canopy:

Transactions arrive late — balances stay correct
Issuer data is imperfect — your ledger is not
Complexity lives in the platform, not your ops team

That is what makes credit products real, auditable, and scalable.