For many manufacturers and distributors, the most valuable customers never browse the website. Their buyers work inside a procurement system, such as SAP Ariba or Coupa, where every purchase starts as a requisition and goes through approval before it becomes an order. If your catalogue is not available from inside that system, buying from you means stepping outside the process the buyer’s organisation has set up. Our view is that, for a large account, that friction is a real commercial risk.
A punchout catalogue solves this. The buyer opens your catalogue from inside their procurement system, sees their own products and contract prices, builds a cart, and sends it back to their system for approval. The purchase order then comes to you electronically.
This article explains how punchout works in plain English, the difference between the cXML and OCI standards, and how to deliver punchout on an Elastic Path storefront. It then covers the part that decides whether a punchout project succeeds: showing each buyer the right catalogue and the right price, and connecting the order that follows to your ERP. Facts about the standards and platforms come from their own documentation, checked on 9 October 2026 and listed at the end. The architecture recommendations are ours.
What the Procurement Platforms Expect
Both of the procurement platforms in this article’s title document punchout from the supplier’s side.
SAP’s learning material for SAP Ariba describes it this way: “PunchOut catalogs (cXML) are live, interactive catalogs that are hosted on the supplier’s website instead of being uploaded to SAP Ariba Procurement solutions.” When the buyer has finished, “the user clicks the site’s check out button, which moves the contents of the shopping cart from the supplier site back to SAP Ariba Procurement.”
Coupa’s supplier documentation is similar: “Punchout catalogs use cXML and create a direct link between the customer’s Coupa instance and the supplier’s ecommerce website.” And: “When a user goes to check out, they’re brought back to Coupa, with the items they chose in their Coupa cart.”
In both cases the catalogue is yours, it runs on your site, and the buyer’s platform expects it to speak cXML.
How a Punchout Session Works
The cXML specification describes the round trip. In outline:
- Setup. The buyer selects your catalogue in their procurement system. “The procurement application generates a PunchOutSetupRequest document and sends it to a network hub, which forwards it to the supplier’s PunchOut website.”
- Redirect. Your site replies with a
PunchOutSetupResponse, which “provides the procurement application with a redirect URL to the supplier’s Start Page”. The buyer lands on your storefront. - Shopping. The buyer browses and builds a cart on your site.
- Cart return. When the buyer clicks your site’s check-out button, which in a punchout session returns the cart rather than placing an order, “the supplier’s website sends a PunchOutOrderMessage document to communicate the contents of the shopping basket to the buyer’s procurement application.”
- Approval and order. “When the purchase requisition is approved, the procurement application converts it into a purchase order and sends it back to the supplier’s website for fulfillment.”
Two consequences of this flow shape everything else.
The cart is not an order. The cXML reference guide is explicit that at the point the cart returns, “Effectively, the supplier has provided a quote for the requested items—the supplier has not yet received a purchase order”. The order comes later, after the buyer’s internal approval.
Approval happens on the buyer’s side. The buyer’s organisation owns the approval workflow. Your systems need to handle the purchase order that results.
cXML and OCI in Plain English
Two standards dominate punchout.
cXML
cXML’s own site describes it as “a streamlined protocol intended for consistent communication of business documents between procurement applications, e-commerce hubs and suppliers.” The specification is published at cxml.org. The current documents are copyright SAP, and the current version at the time of writing is 1.2.071.
A cXML punchout uses a sequence of XML documents:
| Document | What it does |
|---|---|
PunchOutSetupRequest | Sent by the procurement application to start the session. It identifies the buyer and says where to send the cart back. |
PunchOutSetupResponse | Confirms the request succeeded and returns the URL of your storefront’s start page. |
PunchOutOrderMessage | Carries the cart back to the procurement application. |
OrderRequest | The order that follows approval. “The OrderRequest document is analogous to a purchase order.” |
One detail surprises developers new to cXML. The cart does not travel server to server. “Remote websites do not directly send cXML PunchOutOrderMessage documents to procurement applications; instead, they encode them as hidden HTML Form fields and post them to the URL specified in the BrowserFormPost element of the PunchOutSetupRequest.” The cart return passes through the buyer’s browser.
OCI
The Open Catalog Interface (OCI) comes from SAP. Its Release 4.0 specification (2003), published on help.sap.com, describes it as an interface that “incorporates external product catalogs into SRM Server applications”, transferring cart data “directly from the external catalog” using HTTP.
OCI is simpler than cXML. The catalogue returns the cart as an HTML form: “A HTML form is used to transfer the selected product data”. The form is posted to the return URL the procurement system supplied. Field names follow a fixed convention, “NEW_ITEM-HOOK_URL when it is not specified separately.
Which one do you need?
| cXML | OCI | |
|---|---|---|
| Format | XML documents | HTML form fields |
| Session setup | PunchOutSetupRequest and PunchOutSetupResponse | Catalogue URL with parameters, including the return URL |
| Cart return | PunchOutOrderMessage, posted through the browser as a hidden form field | HTML form posted to the return URL |
| Purchase order | OrderRequest | Outside OCI itself; delivered by another channel |
Our answer: the one each buyer’s procurement system uses. For SAP Ariba and Coupa, their documentation points to cXML. A supplier whose large accounts use a mix of platforms will usually end up supporting both.
Delivering Punchout on Elastic Path
Elastic Path Commerce Cloud’s developer documentation does not describe a native punchout feature, and we would not present one. (Elastic Path’s documentation for its Self-Managed Commerce product does describe a punchout integration, but it follows the same pattern: serverless Lambda functions connect the platform to a third-party PunchOut gateway, with TradeCentric named in the deployment instructions.) Punchout is delivered by an integration layer between Elastic Path and the buyer’s procurement system. This is our analysis of how that layer should be designed.
The integration layer’s responsibilities:
- Protocol handling. Receive and validate the
PunchOutSetupRequest(or the OCI entry parameters), authenticate the buying organisation from its credentials, and return the start-page URL. - Session context. Resolve the buying organisation to an Elastic Path account, and start a storefront session in “punchout mode”, where checkout is replaced by “return cart to procurement”.
- Cart return. Convert the Elastic Path cart into a
PunchOutOrderMessageor OCI form, and post it to the buyer’s return URL through the browser. - Order receipt. Receive the
OrderRequest, validate it against what was quoted, and create the order in Elastic Path, the ERP or both.
Build or buy. You can build this layer yourself against Elastic Path’s APIs, or use a specialist eProcurement integration service that already maintains connections to the major procurement platforms. Our view: if you have one or two punchout customers on one protocol, building is viable. If you expect many buyers across several platforms, each with its own onboarding and testing, a specialist service usually costs less than maintaining every connection yourself. Either way, the integration layer is the smaller part of the project. The larger part is what the buyer sees once they arrive.
The Real Work: The Right Catalogue and Price Inside the Session
A punchout session that shows a buyer your public catalogue at list prices is worse than no punchout. The buyer expects their contracted range at their contracted prices. Elastic Path’s account and catalogue model is built for this.
Map the punchout identity to an Elastic Path account. In Elastic Path, “In a B2B scenario, an account will have multiple members from a business unit, all of whom can transact on behalf of their organization.” Our recommendation is that each buying organisation (or business unit, if contracts differ) maps to an account. The punchout setup identifies the buyer, and your integration resolves that identity to the account before the first page loads.
Use catalog rules for the assortment. Elastic Path’s catalog rules link “a shopper’s context (account, customer, channel, or tags) to a published catalog”. They support scenarios such as offering “different products and prices for business customers versus retail customers” and special pricing for a group of buyers. Since November 2025, rules can “target accounts based on their tags, enabling flexible tag-based segmentation for B2B scenarios”. A tag such as framework-agreement-a can then apply one catalogue to every account on that agreement.
Use price books for contract pricing. Elastic Path’s price segmentation guide describes creating “a reseller specific price book” and a catalog rule that uses it as the primary pricing, with a tier price book as the fallback. For punchout, this gives each account its contract prices for contracted lines and a sensible default for everything else.
Make search follow the segment. With Elastic Path’s Catalog Search, “catalog rules and shopper context” control “which catalog a shopper searches”. Since July 2026, “Catalog rules can optionally include a search profile so shopper search follows the same segment as catalog and pricing”. A buyer should never find a product in search that they cannot buy.
Keep the ERP as the System of Record
In most manufacturing businesses, the ERP is the authority for contract prices, credit, stock and orders. Punchout does not change that. If anything, it makes it more important, because the purchase order arrives some time after the cart was priced.
Our recommendations:
- Price from the ERP. Synchronise contract prices into the account-specific price books, or price in real time, but keep one source of truth. We covered the patterns in Your ERP Is the System of Record: Getting Customer-Specific Pricing Right in B2B eCommerce.
- Decide what happens when prices change between cart and order. The returned cart is effectively a quote. Agree with your commercial team how long a punchout price stands, and validate the incoming purchase order against it.
- Route the purchase order to the ERP. Whether the order is created in Elastic Path first or goes directly to the ERP, design the order flow end to end, including acknowledgements, despatch notes and invoices. Our article on connecting Elastic Path to your back office sets out the integration patterns.
Planning a Punchout Programme
This is our recommended sequence.
- List your target accounts and their procurement systems. Each buyer’s platform, protocol and onboarding process differs. Start with the accounts where punchout is a condition of doing business.
- Model accounts, catalogues and price books in Elastic Path first. This is useful for your self-service buyer portal too, and it is a prerequisite for a credible punchout session.
- Decide whether to build or buy the integration layer. Base the decision on the number of buyers and platforms you expect to support, not just the first one.
- Build the order flow to the ERP. Treat purchase order handling and invoices as part of the scope, not a follow-on phase.
- Test each buyer end to end. Run a requisition in the buyer’s test environment, through approval to a purchase order, before going live.
How McKenna Consultants Can Help
McKenna Consultants is a UK Elastic Path consultancy working with manufacturers and distributors. We built a new global composable eCommerce store on Elastic Path for Norgren, a brand of IMI Precision Engineering, and a composable B2B reseller platform for Astrak. We have also delivered the systems integration that connects IMI’s best-of-breed systems.
We can model your accounts, catalogues and contract pricing in Elastic Path, design and build the punchout integration layer, and connect the ERP order flow behind it. Contact us or read more about our B2B eCommerce services and our work in manufacturing and industrial engineering.
Sources
All sources checked on 9 October 2026.
- SAP Learning — Working with PunchOut catalogs: SAP Ariba punchout catalogues use cXML and are hosted on the supplier’s website; cart returned to SAP Ariba Procurement.
- Coupa — Punchout catalogs (supplier documentation): Coupa punchout catalogues use cXML; users return to Coupa with their cart.
- cXML.org — cXML home: definition and current version.
- cXML.org — Getting Started with cXML and cXML Reference Guide: PunchOut protocol; setup request and response; order message and browser form post; requisition as a quote; OrderRequest.
- SAP — Open Catalog Interface (OCI) Release 4.0 (Release 4.0 specification, 2003): definition; HTML form transfer; field naming; HOOK_URL.
- Elastic Path — Account management introduction: B2B accounts with multiple members.
- Elastic Path — Catalog rules: business versus retail catalogues and pricing; preferred accounts.
- Elastic Path — Changelog, 21 November 2025: catalog rules targeting account tags.
- Elastic Path — Price segmentation guide: catalog rules and reseller-specific price books.
- Elastic Path — Changelog, 10 February 2026 and 16 July 2026: Catalog Search; search profiles on catalog rules.
- Elastic Path — PunchOut Gateway, Deploying PunchOut Lambdas and JWT Token Authentication (Self-Managed Commerce): Self-Managed Commerce punchout through a third-party PunchOut gateway and serverless Lambda functions.



