What a CacheFlow integration gives you.
When a primary acquirer experiences latency or outage, CacheFlow automatically routes to secondary providers; checkout continues without customer-facing error messages or manual intervention.
Transactions declined by one acquirer are intelligently retried on alternatives that may have different risk models, reducing failed sales and improving conversion.
Customers' saved cards live in a CacheFlow-managed vault; switching primary acquirers or adding new payment methods does not require customers to re-enter card data.
Standardised CacheFlow settlement feeds reduce manual ERP matching; finance teams can reconcile daily with clear transaction lineage and acquirer-level payout detail.
You define SCA/3DS rules (always, on risk, never) and CacheFlow enforces them consistently across acquirers; compliance teams can audit and update policies without re-building checkout.
Where a CacheFlow integration earns its place.
If two or more of these are true, the integration usually pays for itself quickly.
Where off-the-shelf connectors fall short.
Vendor connectors are fine for simple cases. Here's where the real ones need more.
CacheFlow natively supports common tier-1 acquirers; adding a new or regional acquirer often requires CacheFlow vendor development or custom credential mapping on your side.
Orchestration rules (which acquirer, which 3DS flow, fallback hierarchy) must be defined and maintained by you; CacheFlow does not infer optimal routing without explicit configuration.
Tokens are CacheFlow-managed; if you migrate payment providers, tokens do not automatically port to a new orchestrator and must be re-vaulted or re-collected from customers.
Settlement feeds depend on each acquirer's batch timing; CacheFlow consolidates but does not guarantee same-day reconciliation data, and ERP month-end close may need manual matching.
Liability shift, authentication thresholds and dispute timelines vary by region and network; CacheFlow provides controls but does not automatically enforce local rules.
The pressure to keep checkout available during acquirer incidents often conflicts with the need to maintain clear transaction lineage for settlement reconciliation and month-end close; CacheFlow bridges this gap but only if routing rules, token scope and settlement feed expectations are agreed upfront.
Where this integration sits in your estate.
CacheFlow holds the commercial record. The iWeb integration layer manages the rules, mappings, monitoring and exceptions. The commerce platform presents the customer-facing experience. The estate map helps agree ownership before anything is built.
Commerce platform agnostic. Connect CacheFlow across your entire technology stack.
- Transaction routing rules and acquirer fallback logic
- Card vault and customer payment tokens
- 3DS and SCA authentication policy enforcement
- Settlement detail and reconciliation feed
- Chargeback notification forwarding
- Payment method presentation and customer choice at checkout
- Refund and reversal request initiation
- Token refresh and re-authentication flows
- Checkout error handling and fallback UX
- Transaction logging and audit trail
Systems this integration usually sits next to.
Examples, not a closed list. iWeb is platform-agnostic on both sides: we wire this integration into whatever ecommerce platform and surrounding systems your estate already runs.
- Adobe Commerce
- Magento Open Source
- Shopify Plus
- BigCommerce
- Other storefronts
- ERP system (for order and settlement reconciliation)
- Fraud detection engine (for risk scoring and velocity controls)
- Acquiring banks and payment networks
- Checkout and payment form frontend
- Customer service and dispute management tools
- Finance and reconciliation system
- Chargeback and analytics dashboard
Not sure if this works with your stack?
Tell us what you’re using and what needs to connect. We’ll give you a straight view on what’s possible, what might be awkward, and the safest way to approach it.
The data flows we wire.
Each flow has a direction and an owner. We agree both before a line of code is written.
How iWeb configures the integration around your business.
Same method on every integration. The decisions come before the code.
- 01Map routing rules and fallback hierarchy
We audit your acquirer contracts, transaction volumes and failure patterns to design routing logic that balances resilience, cost and compliance. We define which acquirer owns which transaction type and what fallback paths exist if primary auth fails.
- 02Integrate checkout and tokenisation flow
We connect your commerce platform's payment form and checkout flow to CacheFlow, ensuring payment intent is sent with correct metadata, 3DS preference is respected, and token response is stored for reuse.
- 03Build refund and reversal automation
We design the flow so that when ERP or commerce initiates a refund, it routes to CacheFlow with the original transaction ID, CacheFlow routes to the correct acquirer, and confirmation lands back in ERP.
- 04Configure settlement and reconciliation feeds
We map CacheFlow's settlement export to your ERP format, define reconciliation schedules, and build monitoring so finance teams know when a settlement file is late or unmatched transactions appear.
- 05Design fallback and observability
We establish what happens if CacheFlow itself is unreachable (fallback to direct acquirer, paused checkout, or queued transactions), and set up dashboards so operations teams can see acquirer latency, decline rates and tokenisation vault health.
Who owns what.
The single most important table in any integration. One system owns each field; everything else reads it.
Built payment orchestration before
We have designed and launched payment orchestration estates where availability and resilience matter as much as cost. We understand how CacheFlow's routing logic, token governance and settlement feeds must align with acquirer contracts, fraud policies, ERP reconciliation windows and customer service workflows.
What we test before launch.
Every one of these is rehearsed before a customer ever sees the integration.
Common risks and where they bite.
We name these on day one. A risk written down is a risk you can plan around.
CacheFlow and ERP may record transactions with different timestamps, currency codes or adjustment reasons. If reconciliation is manual or infrequent, mismatches accumulate and finance cannot close the month on time.
When an acquirer changes their API, fraud thresholds or velocity limits, CacheFlow may route transactions differently without alerting you. If not monitored, decline rates spike without visibility into the cause.
If you decide to move away from CacheFlow, existing customer tokens become worthless and you must re-collect card data or migrate to a new vault provider. If not planned, replatform projects stall.
Changing SCA enforcement rules (always vs. on-risk) without staged rollout can unexpectedly trigger 3DS challenges for returning customers, increasing checkout abandonment.
Chargebacks originate from payment networks, land in CacheFlow, but may not automatically flow to commerce or ERP. If no alerting is configured, disputes go unnoticed and response deadlines are missed.
Relevant services and sectors.
Common questions about CacheFlow integrations.
How does CacheFlow prevent a single acquirer outage from breaking checkout?
CacheFlow is configured with a primary acquirer and one or more fallback acquirers. When auth fails or times out on the primary, CacheFlow automatically routes the retry to a secondary acquirer without the customer seeing an error or re-entering payment details.
What happens to customer saved cards if we switch payment orchestration platforms?
CacheFlow-issued tokens are specific to CacheFlow's vault. If you migrate to a different orchestrator, those tokens cannot be reused and customers must re-enter cards or you must maintain a legacy vault in parallel during transition. Plan token migration as part of any payment provider change.
How does CacheFlow routing affect our fraud and chargeback exposure?
Routing decisions should align with fraud risk models; distributing transactions across acquirers spreads fraud liability but also spreads risk exposure. You should define routing rules in consultation with your fraud team and monitor chargebacks by acquirer to ensure the strategy is working.
How does settlement reconciliation work between CacheFlow and ERP?
CacheFlow publishes daily settlement files that summarise captured transactions, refunds, fees and payouts by acquirer. ERP imports and matches these records against commerce transactions. If timing windows differ (e.g., capture-to-settlement lag), reconciliation may require manual adjustment lines until settlement balances.
What is our rollback plan if CacheFlow becomes unreachable?
During CacheFlow outage, the fallback depends on your architecture: if checkout can re-route directly to a backup acquirer, transactions may continue; if not, checkout must queue or pause. Define and test the fallback before launch so you know what happens to customers and ERP order flow.
How do we manage 3DS and SCA enforcement across multiple acquirers?
CacheFlow allows you to define a single 3DS policy (always trigger, trigger on risk score, never trigger) and applies it consistently across all acquirers. Changing the policy requires updating CacheFlow config and should be tested in staging to avoid unexpected authentication friction.
Can CacheFlow tokens be used across multiple commerce platforms or regions?
CacheFlow tokens are vendor-specific and region-agnostic within CacheFlow's infrastructure. You can reuse tokens across multiple commerce instances if they share the same CacheFlow tenant, but token portability depends on CacheFlow's architecture and your contract.
How are chargebacks and disputes reported, and who owns the response?
CacheFlow receives chargeback notifications from payment networks and forwards them to commerce and ERP via API or daily report. Customer service owns investigation and evidence submission; finance owns the P&L impact and reconciliation. Define clear ownership and escalation paths before launch.
What observability and alerting should we set up for CacheFlow?
Monitor transaction volume and decline rates by acquirer, auth latency, tokenisation vault size and failed refunds. Set up alerts for spikes in declines, acquirer unavailability, settlement delays or mismatched transactions so operations can respond before customers or finance notice.
How does CacheFlow handle transactions during network latency or partial outage?
CacheFlow has timeout thresholds; if an acquirer does not respond within the configured window, CacheFlow retries or fails over to a secondary. If CacheFlow itself is slow or unreachable, timeout behaviour depends on your checkout fallback configuration - ensure this is tested and documented.
Who owns the routing rules and how often should they be reviewed?
Payment operations or finance typically owns routing rules in consultation with fraud and compliance teams. Rules should be reviewed quarterly or when acquirer contracts change, and any material change should be tested in staging and rolled out gradually to monitor impact on decline rates and cost.
What happens to in-flight transactions if we need to roll back or revert a configuration change?
Transactions in progress when a rule changes may be routed under old or new rules depending on timing. Have a rollback plan that includes how to handle partial or ambiguous transactions, and ensure monitoring and exception handling are in place so customer service and finance can trace outcomes.
How does CacheFlow pricing integrate with our ERP cost allocation?
CacheFlow charges per transaction or by volume; this cost should flow into ERP via settlement detail or as a separate fees feed. Define how payment processing fees are allocated to orders and channels so margin reporting and P&L are accurate.
Can CacheFlow enforce region-specific payment rules or compliance requirements?
CacheFlow supports configurable policies (3DS, velocity limits, currency handling) but does not automatically enforce regional compliance rules. You must define and maintain compliance rules in CacheFlow and verify that your configuration meets local requirements (PSD2, local network rules, etc.).



