When purchasing managers at large companies ask about e-procurement integration, many manufacturers and wholesalers react with uncertainty. What exactly is behind terms like punchout catalog, OCI, or cXML? And why is this requirement coming up more and more often in B2B sales?
The answer is simple: large purchasing organizations want to digitalize their procurement processes and manage them centrally. Suppliers who cannot embed their catalog directly into the customer's procurement system risk losing the deal altogether. This article explains in four concrete steps how manufacturers and wholesalers can prepare their B2B online shop for punchout integrations and which technical standards matter.
What is punchout and why is it becoming more important in B2B?
Punchout is a technical interface that allows buyers to "punch out" from their procurement system directly into a supplier's online shop. The buyer selects products there, adds them to the cart, and transfers the order back into their own system. The entire purchasing process stays within the customer's familiar system landscape.
For suppliers this means: the customer shops in the supplier's webshop but never sees a checkout page and does not pay directly. Instead, the order is handed over as a structured data record to the customer's ERP or procurement system, where it is approved, checked, and processed.
Why are more and more companies demanding punchout integrations?
The reasons come down to efficiency and control:
Centralized purchasing processes: Large companies want to manage all orders through a single system to centrally control approvals, budgets, and supplier evaluations.
Compliance and transparency: Every order goes through defined approval workflows. This prevents maverick buying (uncontrolled purchases outside approved channels).
Automation: Direct system integration eliminates manual data entry, media discontinuities, and sources of error.
Cost reduction: Purchasing departments significantly reduce process costs per order when they no longer have to switch between different supplier portals.
According to an analysis by Forrester Research from the third quarter of 2026, e-procurement integration is one of the most important requirements in B2B commerce. Shopware is rated a "Strong Performer" in the B2B segment in that report, in part because of its ability to support such integrations. On August 5, 2026, Shopware announced a strategic partnership with TradeCentric, a leading provider of punchout and EDI solutions. This cooperation will make it easier for Shopware customers to connect their B2B shops directly to their buyers' procurement systems.
The most important punchout standards: OCI, cXML, and EDI
Before manufacturers and wholesalers start the technical implementation, they should know the common standards. Three protocols dominate the market:
OCI (Open Catalog Interface)
OCI is a standard developed by SAP that is particularly widespread in Europe. It works via simple URL parameters and HTML forms. The buyer is directed from their SAP system into the supplier's shop via a link, selects products, and sends the order back to the SAP system via HTTP POST.
Advantage: technically easy to implement, low entry barrier. Disadvantage: limited functionality, no real-time validation of prices or availability in the customer system.
cXML (Commerce eXtensible Markup Language)
cXML is an XML-based protocol developed by Ariba (now SAP) and used worldwide. It enables bidirectional communication between shop and procurement system. In addition to orders, order confirmations, invoices, and delivery notes can also be exchanged.
Advantage: comprehensive functionality, widely adopted by large companies. Disadvantage: more complex to implement than OCI, requires XML processing and certification.
EDI (Electronic Data Interchange)
EDI is not a punchout standard in the narrow sense, but an established method for the automated exchange of business documents (orders, invoices, delivery notes). Many large customers expect EDI capability in addition to punchout in order to digitalize the entire procurement cycle end to end.
Advantage: complete process automation, established across industries. Disadvantage: high implementation effort, often requires paid service providers.
The choice of standard depends on the customer's system. SAP customers often require OCI or cXML, Ariba users rely on cXML, and large retail groups additionally demand EDI.
Step 1: Clarify customer requirements and review your system landscape
Before any technical measures are taken, it must be clarified what the customer actually requires. Not every punchout request is the same. The following questions should be answered in advance:
Which procurement system does the customer use? (e.g., SAP Ariba, Coupa, Oracle iProcurement, Jaggaer)
Which punchout standard is required? (OCI, cXML, others)
Are additional functions expected? (e.g., real-time availability, customer-specific prices, multilingual catalogs)
Are there certification requirements or test phases before go-live?
What does the approval process in the customer system look like, and which data fields must be transferred?
In parallel, your own system landscape must be analyzed:
Is the B2B online shop technically capable of processing punchout requests?
Are product data, prices, and availability retrievable in real time?
Is there a middleware or API layer that mediates between shop and ERP?
Are customer-specific conditions reflected in the shop?
Many mid-sized manufacturers discover at this stage that their current webshop is not designed for such integrations. The typical hurdles in connecting ERP, PIM, and shop are covered in the article B2B system integration: 4 hurdles with ERP, PIM & shop. In this case, modernizing the shop platform is often unavoidable. Shopware B2B offers a solid foundation here, as the platform natively supports punchout integrations and, thanks to the TradeCentric partnership, can draw on prebuilt connectors.
Step 2: Technical implementation and interface development
Once the requirements are clear, the technical implementation begins. The effort varies considerably depending on the chosen standard.
OCI implementation
Implementing OCI is comparatively straightforward. The shop must be able to receive URL parameters passed by the customer system (e.g., user ID, session ID, return URL). After product selection, the shop generates an HTML form with the order data and sends it back to the procurement system via HTTP POST.
Typical implementation steps:
Developing an OCI endpoint in the shop
Mapping product data to OCI fields (article number, description, price, quantity, unit)
Session management for punchout users
Testing with the customer system
cXML implementation
cXML requires deeper integration. The shop must receive, process, and return XML messages. Typical message types are:
PunchOutSetupRequest: initiation of the punchout session by the customer system
PunchOutOrderMessage: transfer of the shopping cart back to the customer system
OrderRequest: order from the customer system to the supplier (optional, for a complete order-to-cash process)
The implementation includes:
Building a cXML parser and generator
Authentication and encryption (often via HTTPS and digital signatures)
Validating the XML structure against the cXML schema
Mapping product data, prices, and availability
Error handling and logging
Many companies rely on specialized middleware solutions that mediate between shop and procurement system. TradeCentric offers such connectors, which significantly reduce development effort.
Integration with ERP and PIM
A key challenge is that punchout requests must be served in real time. Product data, prices, and availability should not be stored statically in the shop but retrieved live from the ERP or PIM system. This requires performant API interfaces and a well-thought-out caching strategy. Why up-to-date prices are business-critical in a B2B shop is covered in the article Real-time prices in the B2B shop: why 74% of buyers switch otherwise.
Without this integration, there is a risk that the buyer sees outdated information in the punchout catalog and is later confronted with delivery delays or price discrepancies.
Step 3: Start a pilot project with a first customer
After the technical implementation, a controlled pilot launch with a first customer is recommended. This step serves to test the integration under real conditions and identify any errors before onboarding further customers.
Selecting the pilot customer
Ideally, choose a customer who:
Already maintains a stable business relationship
Has a manageable order volume (to minimize risk)
Is technically savvy and can provide constructive feedback
Is willing to make adjustments together
Test phases and certification
Many procurement systems require formal certification before the supplier is activated. This means:
Running defined test scenarios (e.g., product search, cart, order, cancellation)
Checking data quality (complete article descriptions, correct prices, valid units)
Validating security standards (encryption, authentication)
Documenting all interfaces and data formats
Depending on the system, certification can take several weeks. It is advisable to plan for this period early on.
Monitoring and error handling
During the pilot phase, all punchout sessions should be logged and evaluated. Typical sources of error are:
Timeout problems with slow ERP queries
Inconsistent product data (missing article numbers, wrong units)
Session conflicts with parallel punchout requests
Incorrect price calculations (e.g., missing discounts or tiered prices)
Structured error monitoring helps identify and fix problems quickly.
Step 4: Roll out to additional customers and optimize continuously
After a successful pilot project, the punchout integration can be rolled out to additional customers. A standardized onboarding process should be established, comprising the following steps:
Standardized onboarding process
Requirements gathering: clarifying the customer system, the punchout standard, and specific requirements
Technical configuration: setting up the customer in the shop backend, storing credentials and certificates
Test phase: jointly running defined test scenarios
Go-live: activating the production environment
Support: providing contacts for technical and business questions
The more customers are connected, the more important a central administration of all punchout connections becomes. Modern B2B platforms like Shopware offer admin interfaces for managing all customers, their systems, and configurations in one place.
Scaling and performance
As the number of punchout customers grows, so does the load on the shop system. The following measures help safeguard performance:
Caching: frequently requested product data should be cached to reduce ERP queries
Load balancing: distributing requests across multiple servers
Asynchronous processing: time-intensive processes (e.g., stock queries) should run asynchronously
Monitoring: continuous monitoring of response times, error rates, and system load
Continuous optimization and further development
Punchout is not a one-off project but an ongoing process. Customer systems are updated, new standards emerge, and requirements change. Regular reviews help maintain the quality of the integration:
Quarterly evaluation of punchout usage (number of sessions, average cart size, error rate)
Feedback rounds with customers to identify improvement potential
Technology updates: adapting to new versions of procurement systems or shop platforms
Training: regular upskilling of your own team on new standards and best practices
What role does the choice of shop platform play?
Not every e-commerce platform is equally suited to punchout integrations. The decisive criteria are:
Native support for common punchout standards (OCI, cXML)
Flexible API architecture for connecting ERP, PIM, and middleware
Multi-client capability for managing customer-specific catalogs and prices
Performance and scalability for high request volumes
Availability of connectors to common procurement systems
Shopware B2B meets these requirements and is further strengthened by the TradeCentric partnership. TradeCentric offers prebuilt connectors to more than 100 procurement systems, including SAP Ariba, Coupa, Oracle, and Jaggaer. This significantly reduces implementation effort and accelerates go-live. Which requirements a Shopware-based B2B shop should meet beyond that is summarized in the article Shopware for B2B: check these 12 requirements.
For manufacturers and wholesalers that do not yet have a suitable platform in place, an early evaluation pays off. Choosing a punchout-capable platform saves costs in the long run and avoids later migrations.
Common mistakes in punchout projects
Despite careful planning, many punchout projects fail or are significantly delayed. The most common causes:
Unclear requirements
Many projects start without the customer's technical requirements being fully clarified. This leads to rework, delays, and frustration on both sides. A detailed requirements analysis at the outset is indispensable.
Underestimating the complexity
OCI sounds simple, cXML complex. But OCI implementations can also fail if session management, data mapping, or error handling are not implemented cleanly. The technical complexity should not be underestimated.
Missing ERP integration
A punchout catalog without real-time connection to ERP or PIM is of little value. Outdated prices or availability lead to complaints and damage the customer's trust.
Insufficient test coverage
Many errors only show up in production. A comprehensive test phase with realistic scenarios (parallel sessions, high load, edge cases such as cancellations) is crucial.
Missing documentation
Without clear documentation of interfaces, data formats, and processes, every extension or troubleshooting effort becomes a challenge. Technical documentation should be maintained from the start.
Outlook: punchout as a strategic competitive advantage
The ability to offer punchout integrations is increasingly evolving from a nice-to-have to a must-have in B2B sales. Large purchasing organizations rely on central procurement systems, and suppliers without the corresponding interfaces risk falling out of the preferred supplier pool.
At the same time, punchout opens up new opportunities:
Higher customer retention: once integrated, customers switch suppliers less often
More efficient processes: fewer manual orders, fewer errors, faster processing
Scalability: new key accounts can be onboarded faster
Competitive advantage: those who master punchout stand out from competitors without this capability
Investing in punchout-capable infrastructure pays off in the long term. Manufacturers and wholesalers that lay the technical groundwork now are positioning themselves for the next phase of digital sales.
