Checkout Rules for Agentic Commerce on Shopify

Shopify checkout rules used to feel like a checkout customization problem. If a merchant needed to block an order, reject an invalid condition, or require a buyer to fix something before payment, that logic often lived close to the checkout interface.

That model is changing. On July 2, 2026, Shopify announced that starting with API version 2026-07, the useBuyerJourneyIntercept hook in checkout UI extensions and the related block_progress capability are deprecated. Existing extensions continue to work on current and prior API versions, but Shopify recommends migrating merchant business rules to Cart and Checkout Validation Functions.

This matters because checkout is no longer only one page in one browser session. Buyers may use Shop Pay, Apple Pay, Google Pay, PayPal, custom storefronts, mobile experiences, or AI-powered shopping flows. Agentic commerce makes the shift more urgent: if an AI assistant can help create carts, compare products, and move a buyer toward checkout, stores need one reliable place where business rules are enforced.

For Shopify merchants, the practical question is simple: which checkout rules must move server-side first?

The Important Clarification

This is not a panic deadline. Shopify has not said that existing checkout UI extensions using useBuyerJourneyIntercept will stop working immediately. The API is deprecated as of version 2026-07, and Shopify has said it will be removed in a future version.

That still deserves action now. Deprecated checkout logic is not where merchants want critical revenue, risk, compliance, or customer experience rules to live. If a rule decides whether an order can be placed, it should be reliable across every checkout surface.

This is the third Shopify API transition merchants are tracking this year, alongside the checkout extension deadline and the Customer Account API deadline - all pointing in the same direction: business-critical logic needs a stable, server-side home.

Why Client-Side Blocking Is No Longer Enough

Client-side checkout blocking runs in the buyer’s browser. That can work in normal checkout flows, but it is not the most reliable foundation for business-critical rules.

There are several reasons. First, accelerated wallets and express checkout flows do not always behave like standard checkout. A buyer may move quickly from product page or cart to payment without interacting with every checkout step where a UI extension expects to run.

Second, browser-based logic can be affected by connection quality, device behavior, script timing, extension state, or app configuration. That is a risky place to enforce rules such as minimum order value, country restrictions, COD availability, age-sensitive products, or B2B purchase requirements.

Third, agentic checkout introduces new surfaces. If AI systems and external commerce agents can help shoppers build carts and proceed toward checkout, the merchant’s rules need to apply whether the buyer is using the storefront UI, a wallet, or an agentic commerce flow.

Server-side validation gives merchants a more stable foundation. Shopify’s Cart and Checkout Validation Functions are designed to run on Shopify’s backend logic and apply rules consistently across checkout surfaces.

Blocking Logic Is Business Logic

Checkout rules are not just technical details. They protect margin, reduce failed orders, prevent operational mistakes, and set clear expectations for buyers.

For example, a checkout rule may decide:

• Whether Cash on Delivery is available for a specific country, cart value, postal code, or product category
• Whether a B2B buyer meets a minimum order value
• Whether a PO number is required
• Whether restricted products can ship to a certain market
• Whether a delivery address is serviceable
• Whether a subscription product can be purchased with a one-time product
• Whether a discount code should be rejected because it conflicts with another offer
• Whether a buyer must fix missing or invalid checkout information before payment

If those rules fail, the issue is rarely limited to checkout UX. The merchant may deal with canceled orders, support tickets, failed deliveries, manual refunds, warehouse exceptions, or unhappy customers.

That is why Shopify stores should treat this migration as an operational audit, not only a developer task.

Which Checkout Rules Should Move Server-Side First

Start with rules that block an order, change financial outcomes, or prevent fulfillment problems.

1. COD Eligibility and Payment Rules

Cash on Delivery can increase trust and conversion in some markets, but it also introduces operational risk. COD should not always be available for every order.

A store may need rules based on:

• Cart value
• Country, region, or postal code
• Product type
• Previous failed orders
• Phone verification status
• Delivery method
• COD fee eligibility

If COD logic is only shown or blocked in the frontend, it may not apply consistently across accelerated or agentic checkout surfaces. Merchants using COD should review whether availability, fees, and verification rules are enforced in the right layer.

Tools such as Progus COD Form can help merchants control COD availability with smart rules, simplified COD ordering, and optional OTP verification. For broader context, Progus also has a practical guide to Cash on Delivery in ecommerce and how COD can affect trust, risk, and checkout completion.

2. B2B Minimums and Purchase Requirements

B2B checkout often depends on stricter rules than DTC checkout.

Examples include:

• Minimum order value
• Minimum quantity by product or case pack
• Required PO number
• Customer-specific eligibility
• Company location rules
• Payment term restrictions
• Product availability by catalog

These rules should not depend only on visible checkout messaging. If a wholesale buyer does not meet the requirement, the order should be blocked reliably before payment.

This becomes even more important as AI-assisted procurement grows. A buying assistant may prepare a cart based on product data and account terms. The final validation still needs to happen in a consistent backend layer.

3. Product, Market, and Compliance Restrictions

Some products should not be sold in every market or in every combination.

A merchant may need to block checkout when:

• A product cannot ship to a specific region
• A restricted item requires a certain buyer attribute
• A bundle contains incompatible products
• A product is unavailable for the selected market
• A local regulation requires missing product information
• A delivery method is not allowed for the cart contents

This is where product data and checkout rules connect. If the product catalog is unclear, inconsistent, or incomplete, checkout validation becomes harder to maintain. Merchants preparing for AI-assisted buying should also review their product data structure, as covered in Progus’s guide on optimizing Shopify product data for AI shopping.

4. Delivery and Address Rules

Delivery restrictions are a common source of checkout problems. A buyer may enter an address that looks valid but cannot actually be served by the merchant’s carrier, warehouse, pickup network, or delivery schedule.

Server-side validation is especially useful for rules such as:

• Unsupported postal codes
• Missing apartment or house number details
• Delivery date requirements
• Product-specific delivery exclusions
• Fresh, fragile, oversized, or regulated goods
• Pickup-only products
• Local delivery boundaries

However, not every address validation flow is simple. Some merchants rely on third-party address APIs or live carrier checks. These cases may need a redesigned architecture, because Shopify Functions do not work like a normal frontend script that can freely call any external service during checkout.

The practical takeaway: identify these cases early. Do not wait until the old checkout interception logic becomes harder to maintain.

5. Discount and Offer Rules

Not every checkout rule belongs in Cart and Checkout Validation Functions.

Shopify’s July 2026 changelog specifically says that if useBuyerJourneyIntercept is being used to reject discount codes, merchants should migrate that logic to the Discount Function API, which supports rejecting discount codes with a custom message.

This matters for stores with complex promotion logic, such as:

• Discounts that should not stack
• B2B customers excluded from retail promotions
• Subscription products excluded from first-order offers
• COD orders excluded from certain discounts
• Market-specific discount rules
• Upsell offers that should only apply to eligible products

Discount logic should be tested carefully because it affects both margin and customer trust. A buyer may forgive a missing badge. They will be far less forgiving if a discount appears valid and then fails without a clear explanation.

What Should Stay in the UI

Moving blocking logic server-side does not mean the checkout UI becomes unimportant.

The UI should still explain, guide, and reassure. Server-side validation decides whether the order can proceed. The interface should help the buyer understand what to fix.

Good UI-layer examples include:

• Showing a message that COD is unavailable for the selected address
• Explaining why a product cannot ship to a region
• Prompting a B2B buyer to enter a PO number
• Displaying delivery instructions near the relevant field
• Showing trust badges or payment reassurance near payment options
• Warning that a discount cannot be combined with another promotion

This is where conversion and trust still matter. A rule that blocks checkout without clear messaging can create support tickets and abandoned carts. Merchants should review not only whether a rule works, but whether the buyer understands it.

For customer confidence around sensitive checkout moments, Progus’s article on where to place trust badges is a useful companion piece.

A Practical Audit for Shopify Merchants

Before asking a developer to migrate anything, make a list of every checkout rule currently used by the store.

Use these categories:

Critical rules: If this rule fails, the store may accept an order it cannot fulfill, ship, price correctly, or legally process. See the rule categories above for the most common examples.

Important rules: If this rule fails, the store may lose margin, create support work, or confuse customers. These are usually rules around pricing, payment eligibility, subscriptions, delivery promises, or offer logic.

UX-only rules: If this rule fails, the buyer may be less informed, but the order itself is still valid. These can usually stay in the interface as guidance, reassurance, or optional messaging.

Once the rules are grouped, review where each rule currently lives:

• Checkout UI extension
• Theme code
• App setting
• Shopify Function
• Shopify Flow
• Discount configuration
• Custom app backend
• ERP, PIM, WMS, or third-party API

The goal is not to move everything into one place. The goal is to make sure blocking rules live in the layer that can actually enforce them.

Questions to Ask Developers and App Vendors

Merchants should not need to read checkout extension code to understand their risk. They can ask focused questions.

1. Are any of our checkout rules using useBuyerJourneyIntercept or block_progress?
2. Which checkout UI extension API versions are currently used
3. Which rules block checkout, and which only show warnings?
4. Have our blocking business rules been migrated to Cart and Checkout Validation Functions where appropriate?
5. Are any discount rejection rules still handled through checkout UI logic instead of Discount Functions?
6. Does the validation work with Shop Pay, Apple Pay, Google Pay, PayPal, and standard checkout?
7. Has the logic been tested for agentic checkout or API-driven checkout surfaces where available?
8. What data does the Function rely on: cart attributes, metafields, metaobjects, customer data, product data, or app-owned data?
9. How is that data updated, and how do we prevent stale rule decisions?
10. What message does the buyer see when checkout is blocked?
11. Can the error message point to the field or cart issue the buyer needs to fix?
12. How will we know if a validation Function is disabled, misconfigured, or not active on the right checkout profile?

These questions help turn a platform change into a controlled migration plan.

What to Test Before Peak Season

A checkout rule is only ready when it has been tested against real customer journeys.

Use this test list before major campaigns, seasonal traffic, or BFCM planning:

• Standard checkout with eligible and ineligible carts
• Mobile checkout
• Shop Pay and accelerated wallet flows
• Valid and invalid discount code scenarios
• COD-eligible and COD-ineligible orders
• B2B orders below and above the minimum order value
• B2B checkout with and without a PO number
• Subscription-only cart
• Mixed subscription and one-time cart
• Restricted product by market or region
• Unsupported delivery address
• Local pickup or locker delivery where relevant
• Cart updates after a validation error appears
• Checkout retry after the buyer fixes the issue

For EU-facing stores, also test checkouts that include a final review or order confirmation step. The team should verify exactly when the validation runs, where the error appears, and whether the buyer can still correct the issue before placing the order.

Track the result in plain language:

• Rule triggered correctly
• Buyer saw a clear message
• Buyer knew what to fix
• Order was blocked only when necessary
• Valid orders were not blocked
• Support team knows how to explain the rule

This prevents the most common migration failure: technically correct validation that still creates buyer confusion.

Where Progus Fits

This topic is especially relevant for Shopify merchants using apps around COD, subscriptions, upsells, delivery options, trust messaging, and checkout conversion.

That does not mean every app needs to become a validation Function. It means merchants should understand which parts of the buying journey are only presentation and which parts are business rules.

For example:

• A trust badge reassures the buyer, but it should not decide whether an order is valid.
• A COD form may help collect or verify information, but COD eligibility still needs reliable enforcement.
• An upsell offer may improve AOV, but discount and eligibility rules must protect margin.
• A subscription widget may explain the offer, but subscription checkout rules must prevent invalid combinations.

This is the broader shift in Shopify commerce: the storefront can be flexible and expressive, but the rules behind buying need to be structured, testable, and reliable.

A Simple Migration Timeline

Merchants do not need to fix everything in one sprint. They do need a plan.

Now: Inventory every checkout rule and identify whether it blocks checkout, changes pricing, affects fulfillment, or only displays information.

Next: Prioritize high-risk rules: payment eligibility, delivery restrictions, B2B requirements, restricted products, COD rules, and discount rejection.

Then: Ask app vendors and developers which rules use deprecated checkout interception and which have already moved to Shopify Functions.

Before peak season: Test critical checkout journeys across standard checkout, mobile, accelerated wallets, and relevant app-driven flows.

After launch: Monitor failed checkout attempts, abandoned carts, support tickets, invalid orders, discount errors, COD failures, and fulfillment exceptions.

Final Thoughts

Agentic commerce does not remove the need for checkout rules. It makes them more important. As more buying journeys happen across wallets, AI surfaces, custom storefronts, and app-driven checkout experiences, Shopify merchants need blocking logic that runs consistently outside the buyer’s browser. The July 2026 deprecation of useBuyerJourneyIntercept is a clear signal: business-critical checkout rules belong server-side.

The best next step is not panic. It is an audit. Identify the rules that protect revenue, trust, delivery, compliance, and customer experience. Move the right ones to Shopify Functions. Keep the UI helpful. Then test the journeys that real buyers, and soon more AI-assisted buyers, will actually use.