What a cXML integration gives you.
Every incoming cXML PO is validated against account mapping, contract pricing and availability before acknowledgement. Procurement teams see fast, clear responses instead of orders vanishing into a queue.
Acknowledgements, ASNs and invoices are sent in time with correct line status, tracking and financial detail. Three-way matching in the buyer's system completes without exceptions or re-submissions.
Mis-mapped buyer accounts, pricing mismatches, quantity rejections and connectivity failures are visible to the operations team and escalated before they affect a shipment or invoice.
Contract terms and volume pricing are validated on every PO. You do not accept orders outside agreed terms, and you do not ship product that breaks a pricing guarantee.
Where a cXML 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.
cXML messages carry buyer IDs and tax IDs, but your commerce platform and ERP use different customer account codes. Without integration configuration, the system cannot reliably map incoming POs to the right customer record, causing mis-routed orders or manual queue work.
Buyer-specific pricing, volume discounts and contract terms live in your ERP or pricing engine, not in cXML. The integration must validate each line item against contract terms before accepting the PO; without this, you may accept orders below agreed pricing.
cXML does not dictate when acknowledgements are sent or what status fields are mandatory. If your ERP and procurement system disagree on acknowledgement timing or content, messages may be rejected or procurement may see stale status.
If the buyer's cXML endpoint is down or your internet connection fails mid-message, purchase orders may be held in a queue with no clear path to recovery. The integration must define retry logic, dead-letter queues and manual escalation paths.
As your ERP or fulfillment processes change, the cXML fields you send in ASNs and invoices may diverge from what the buyer expects. Without governance, format mismatches cause three-way matching failures and procurement complaints.
Mapping a buyer ID to the right customer record and validating contract pricing before you acknowledge an order are often the difference between a fast, clean transaction and a procurement complaint that arrives at your sales desk.
Where this integration sits in your estate.
cXML 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.
No platform lock-in. We integrate cXML with the commerce core you already have, or the one you are moving to.
- cXML message format and schema
- Buyer account mapping rules
- Contract pricing validation logic
- Purchase order intake and routing
- Acknowledgement and ASN formatting
- Invoice and credit-note exchange
- Catalogue visibility and punchout session
- Order capture and routing to fulfillment
- Inventory allocation and availability
- Dispatch confirmation and ASN trigger
- Invoice and billing generation
- Customer and buyer account records
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.
- Magento Open Source
- Adobe Commerce
- Custom headless ecommerce
- Other storefronts
- ERP (SAP, Sage, NetSuite, Infor)
- Order management system
- PIM for approved product lists
- Pricing engine or contract management
- WMS for dispatch and ASN
- Procurement platforms (Ariba, Coupa, Jaggr)
- Accounting and invoicing system
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.
- 01Design account mapping and lookups
iWeb maps buyer IDs, tax IDs and location codes to your internal customer and order-destination records. The integration validates and enriches each PO with the right account context before routing.
- 02Configure contract pricing validation
iWeb integrates with your ERP or pricing engine to validate line items against buyer-specific pricing, volume discounts and contract terms. Rejections are documented and returned in cXML format.
- 03Build acknowledgement and ASN workflows
iWeb defines when acknowledgements are sent (on order capture, on allocation, or on fulfillment). ASNs are generated from your ERP or WMS dispatch confirmations and formatted in cXML for the buyer procurement system.
- 04Manage message validation and routing
iWeb validates incoming cXML against schema, logs message content for audit, routes to order management or ERP, and queues exceptions. Outbound messages are validated before sending so the buyer receives well-formed data.
- 05Define governance and exception handling
iWeb names who owns buyer accounts, contract terms, acknowledgement timing and failure escalation. Dead-letter queues and manual review paths are documented and monitored.
Who owns what.
The single most important table in any integration. One system owns each field; everything else reads it.
Built this before
iWeb has designed and operated cXML integrations for B2B and trade buyers. We understand how procurement systems expect messages to flow, how buyer accounts and contract pricing must be validated, and where connectivity and governance gaps cause operational friction.
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.
If a buyer ID in the cXML PO does not map to a customer record in your system, the order is either rejected or routed to the wrong location. This surfaces as a procurement complaint when the order disappears or ships to the wrong address.
Without validation against contract pricing, you may accept a PO for 1,000 units at a price that is below agreed terms or below your cost. This is discovered during fulfillment or invoicing and is difficult to reverse.
If your ERP is slow to capture orders, or if acknowledgements are sent before inventory is allocated, the buyer procurement system receives conflicting status. They may re-submit the PO or escalate to your sales team.
If the buyer's cXML endpoint is unreachable or your internet connection drops, acknowledgements and ASNs may not be sent. The buyer assumes the order was rejected, and your warehouse is already working on fulfillment.
If your ERP invoices do not map cleanly to the cXML format the buyer expects, or if line-item references do not match the original PO, the buyer cannot match invoice to order and blocks payment.
If POs are held in an exception queue because of mapping or pricing issues, and no one is monitoring the queue, orders sit for days without being routed or rejected. This leads to late or missed shipments.
Relevant services and sectors.
Common questions about cXML integrations.
What is cXML and why do we need it?
cXML is a structured XML standard for B2B order exchange. It allows procurement systems (like Ariba, Coupa, Jaggr) to send purchase orders to your commerce or ERP system in a standardized format, and for you to send acknowledgements, ASNs and invoices back in the same language. Without cXML, buyers would have to enter orders manually or use proprietary EDI formats, increasing errors and reducing speed.
How do we map buyer account IDs to our customer records?
The integration maintains a mapping table that links buyer IDs (and sometimes tax IDs or location codes) to your internal customer account, billing address and delivery location. This mapping is loaded into the integration at startup and refreshed periodically from your ERP or CRM. When a cXML PO arrives, the integration looks up the buyer ID, resolves the customer record, and enriches the order with customer context before routing.
How do we validate contract pricing on incoming orders?
Before accepting a cXML PO, the integration queries your ERP or pricing engine for the buyer's contract terms, volume discounts and approved product list. Each line item is validated against the contract. If a line item is priced below contract, ordered above or below volume thresholds, or not on the approved list, the integration documents the rejection reason and returns a rejection message in cXML format to the buyer.
When should we send an acknowledgement, and what should it say?
This is agreed with the buyer upfront. Some buyers want an immediate technical acknowledgement (within minutes) confirming receipt of the PO. Others want a business acknowledgement after inventory allocation. The integration sends the message when your order-management system reaches the agreed trigger point. The acknowledgement includes order number, line status (accepted, rejected, quantity adjusted), expected delivery date and any notes. The buyer imports this into their procurement system to confirm the order is progressing.
What happens if a cXML PO arrives but our system cannot accept it?
The integration validates the PO against schema and business rules. If validation fails (missing required fields, invalid buyer account, pricing mismatch, inventory unavailable), the integration generates a rejection message in cXML format and sends it back to the buyer. The rejection includes the reason code so the buyer knows whether to resubmit with corrections or escalate. If the buyer's endpoint is unreachable, the integration retries according to a defined schedule and logs the failure for manual review.
How do we send ASNs (advanced shipping notices) to the buyer?
When an order is despatch-confirmed in your WMS or ERP, the integration generates an ASN in cXML format. The ASN includes the order number, line items, quantities shipped, carrier name, tracking number and expected delivery date. This is sent to the buyer's procurement system so their receiving team can prepare for inbound delivery and match the shipment to the PO.
How do we handle invoice and credit-note exchange?
When billing is generated in your ERP, the integration formats the invoice in cXML, including original PO number, line-item references, quantities, prices and total amount. This is sent to the buyer for three-way matching (PO, receipt, invoice). If you issue a credit note for a return or adjustment, the same process applies. The buyer imports these into their procurement and accounting system for reconciliation.
What if the buyer's cXML endpoint is down or the connection fails?
The integration logs the failure and queues the message for retry. Retries follow a defined schedule (e.g., every 5 minutes for 1 hour, then every hour for 24 hours). If the buyer remains unreachable after the retry window, the integration alerts the operations team for manual escalation. Acknowledgements and ASNs are not held indefinitely; if delivery fails after a defined number of retries, the order is escalated to sales or customer service.
How do we audit cXML messages for compliance and disputes?
Every inbound and outbound cXML message is logged with timestamp, sender ID, message type, content hash and processing status. Logs are stored for audit and legal holds. If a buyer disputes whether an acknowledgement was sent or an ASN was received, you can retrieve the exact message and proof of delivery from the logs. This is especially important for contract disputes or chargeback claims.
How do we handle buyer-specific product lists and pricing tiers?
Buyer-specific pricing and approved product lists are stored in your ERP, PIM or pricing engine. The integration retrieves this data when a cXML PO arrives and validates each line item against the approved list and pricing tier. If a buyer orders a product outside their approved list or at a quantity outside their discount tier, the order is either rejected or adjusted and returned to the buyer in the acknowledgement message.
Can we use cXML for punchout sessions?
Yes. A punchout session allows a buyer to browse and order through your commerce storefront while staying logged into their procurement system. The cXML flow for punchout is: the buyer's procurement system sends a cXML ProfileRequest to your integration. The integration creates a temporary session, maps the buyer account, applies their contract pricing and approved product list, and returns a session token. The buyer browses your storefront with their profile loaded. When they check out, their selections are sent back to the procurement system in cXML format.
Who owns the cXML message templates and validation rules?
This is defined upfront in the integration governance. Typically, your integration team owns the templates and rules. Before launch, the buyer signs off on the message format, required fields and validation logic. If the buyer or your business processes change (e.g., new required field on the acknowledgement, new pricing tier), the templates and rules are updated and tested before going live. This is part of change management, not ad-hoc troubleshooting.
What is the difference between cXML and EDI, and which should we use?
EDI (like EDIFACT or X12) is a fixed-format standard used for decades in retail and logistics. cXML is XML-based, designed for B2B procurement, and is easier to parse and validate. If you are selling to large enterprise buyers with procurement systems (Ariba, Coupa, Jaggr, Punchout), cXML is the modern standard. If you are selling to smaller trading partners or logistics networks, EDI may be used. Many sellers support both; the choice depends on the buyer's procurement platform and your operational capacity.



