UCP for B2B Commerce: How Enterprise Agents Handle Complex Orders

B2B commerce and B2C commerce are different protocols wearing the same UCP clothes. The checkout spec is the same. The manifest is the same. But what happens inside a B2B checkout session diverges significantly from consumer checkout.

This guide covers what enterprise UCP looks like from an agent developer's perspective: what data structures change, what workflows you have to handle, and what the major enterprise platforms are building.

Why B2B Is Different

In B2C, checkout is simple: consumer picks items, presents payment token, purchase completes. The payment method is a card or wallet. Payment happens at checkout. The buyer is the same as the end user.

In B2B, none of these assumptions hold:

• Payment method is often a credit line, not a card. A buyer operating on Net 30 terms does not pay at checkout. An invoice is generated, and payment happens 30 days later.
• The buyer and the end user are different entities. A procurement agent acts on behalf of a company, not an individual. The company has a credit limit, a catalog, and pricing that are different from any individual employee's.
• Orders above a threshold require approval. A buyer agent may be authorized to purchase up to $5,000 without approval. Orders above that amount go to a manager for sign-off before the merchant fulfills.
• Pricing is negotiated, not listed. A large buyer's contract price for industrial components may be 40% below list price. That pricing is tied to the buyer's company identity, not their individual account.
• Multiple buyers can act on behalf of the same company. Requisition workflows mean that one employee creates a draft order and another approves it.

An agent that treats a B2B checkout endpoint like a B2C checkout endpoint will hit errors, get incorrect pricing, and skip required workflow steps.

Identity Linking in B2B Context

UCP's identity-linking capability is the mechanism that carries B2B entitlements into a checkout session. When a consumer uses identity linking with a B2C merchant, the linked identity is an individual shopper profile. When a buyer uses identity linking with a B2B merchant, the linked identity is a company account.

A B2B identity token carries:

• Company ID and account status
• Buyer's role within the company (can approve, can purchase, can view-only)
• Purchase limit for this buyer without approval
• Credit line balance and terms (Net 30, Net 60, etc.)
• Catalog ID for the customer-specific product set
• Customer-specific pricing tier

The merchant's UCP checkout endpoint resolves this identity token against its customer database and returns a checkout session shaped by the company's contract terms.

// B2B identity token structure (illustrative)
interface B2BIdentityToken {
  ucpTokenType: 'identity';
  companyId: string;
  buyerId: string;
  buyerRole: 'purchaser' | 'approver' | 'admin';
  purchaseLimit: number;     // max order value without approval
  catalogId: string;         // customer-specific product set
  paymentTerms: 'net30' | 'net60' | 'prepaid';
  creditLineBalance: number; // remaining available credit
}

// When resolved at checkout endpoint:
const session = await initiateB2BCheckout(manifest, {
  identityToken: b2bIdentityToken,
  items: orderItems,
});

// Session reflects company terms:
// session.unitPrices   -> contract pricing, not list pricing
// session.paymentMethod -> 'net30' or 'net60', not card
// session.approvalRequired -> true if order.total > token.purchaseLimit

Purchase Orders and Net Terms

The biggest structural difference in B2B checkout is that payment does not complete at checkout. Net terms mean the buyer receives goods and pays later. The checkout response includes a purchase order record rather than a payment confirmation.

Your agent needs to handle this differently from card payment:

async function handleB2BCheckout(
  session: UcpCheckoutSession
): Promise<B2BOrderResult> {
  if (session.paymentMethod === 'net30' || session.paymentMethod === 'net60') {
    // No payment authorization needed. Merchant invoices later.
    return {
      status: 'order_placed',
      poNumber: session.purchaseOrderNumber,
      invoiceDueDate: session.invoiceDueDate,
      orderId: session.orderId,
    };
  }

  // Prepaid: standard card payment flow
  return handleCardPayment(session);
}

Your agent should record the PO number and invoice due date. If you are building a procurement agent, you may need to notify the buyer's accounts payable system to expect an invoice on that date.

Approval Workflows

When a buyer's order exceeds their purchase limit, the checkout endpoint returns a pending approval response rather than a confirmed order. Your agent has to handle this as an asynchronous workflow.

const session = await initiateB2BCheckout(manifest, checkoutRequest);

if (session.status === 'pending_approval') {
  // Order is not placed yet. Waiting for approver.
  await notifyApprover({
    approverId: session.approverId,
    orderSummary: session.summary,
    approvalUrl: session.approvalUrl,
    sessionId: session.id,
  });

  // Poll or webhook: check approval status
  const approved = await waitForApproval(session.id, { timeoutMs: 86400000 });

  if (approved) {
    // Re-confirm checkout with approval token
    return confirmApprovedOrder(session.id, approved.token);
  } else {
    return { status: 'approval_rejected', sessionId: session.id };
  }
}

Do not treat a pending approval response as a successful order. The merchant will not fulfill until the approval is complete. Build the approval polling or webhook handling before shipping a B2B procurement agent.

Multi-Buyer Accounts and Requisition Lists

Enterprise procurement often uses requisition workflows: one employee builds a draft order, another reviews and approves it before submission. In UCP terms, this means multiple identity tokens can interact with the same draft checkout session.

The pattern:

1. Purchasing agent creates a draft checkout session with a requester identity token.
2. Session is stored with status draft.
3. Approver agent (different identity token, same company) reviews the draft and confirms.
4. Confirmed session submits the order.

// Create draft session (requester)
const draft = await fetch(manifest.checkoutEndpoint, {
  method: 'POST',
  body: JSON.stringify({ ...checkoutRequest, status: 'draft' }),
}).then(r => r.json());

// Share draft ID with approver
await notifyApprover(draft.sessionId);

// Approver reviews and confirms (separate agent context)
const confirmed = await fetch(`${manifest.checkoutEndpoint}/${draft.sessionId}/confirm`, {
  method: 'POST',
  headers: { 'X-UCP-Identity-Token': approverToken },
}).then(r => r.json());

Not all B2B UCP implementations support requisition workflows yet. Check the platform's UCP documentation for draft session support before building this flow.

What SAP Commerce Cloud and Salesforce Commerce Cloud Are Building

SAP Commerce Cloud has announced UCP integration that maps directly to SAP ERP. An agent-initiated B2B order creates an SAP sales order in the connected ERP system. The checkout session carries SAP customer account numbers, material codes (not generic SKUs), and delivery scheduling tied to SAP logistics. Agent developers targeting large manufacturers using SAP need to handle SAP-specific data formats in the checkout response.

Salesforce Commerce Cloud is integrating UCP through its Agentforce platform. The identity-linking implementation uses Salesforce CRM as the identity source, giving buyer context that includes full CRM history, loyalty data, and service interactions. Agents built on Salesforce's stack can use Salesforce Flow to automate approval workflows triggered by UCP checkout events.

Adobe Commerce (Magento) has announced UCP support for its B2B module, which handles company accounts, shared catalogs, and negotiated pricing natively. The UCP integration exposes these features through the standard identity-linking and order-management capabilities.

What Agent Developers Should Do Now

These platforms have announced UCP support but none are live yet as of mid-2026. Use this time to:

1. Map your agent's identity model to B2B identity linking. Decide how your agent will carry buyer company credentials. Will buyers pre-authorize B2B identity tokens in your agent platform? How will you handle role-based purchase limits?

1. Build approval workflow handling. If your agent targets enterprise procurement, the approval workflow is not an edge case. It is the normal path for high-value orders.

1. Implement PO-based payment handling. Your agent should not expect immediate payment confirmation for all B2B checkouts. Build invoice tracking if your use case requires it.

1. Test against the UCP Conformance Suite. The UCP Conformance Suite includes B2B test cases. Run them against any B2B platform endpoint when they go live.

The B2B UCP opportunity is large. Enterprise procurement spend dwarfs consumer ecommerce. But it requires more agent complexity than consumer checkout. Build that complexity now so you are ready when the enterprise platforms go live.