Browse apps

Security

Shopify Checkout Validation Functions: Stop Fraud Before Capture

TL;DR

Shopify Cart and Checkout Validation Functions execute server-side on Shopify infrastructure whenever a buyer advances through cart or checkout. Unlike browser scripts that can be bypassed by disabling JavaScript—or post-order cancellations that forfeit payment gateway fees—a validation function inspects buyer identity and delivery data in real time and blocks matching checkouts before payment capture.

When a fraudulent or abusive order hits a Shopify store, the exact millisecond your defense runs determines whether you lose money. If you rely on post-order workflows to cancel bad purchases after checkout completes, your payment gateway has often already authorized—or captured—the transaction, leaving you with non-refundable processing fees. If you rely only on browser scripts to hide the checkout button, anyone who turns off JavaScript or uses a direct checkout link can walk right past your rules.

To block orders before payment capture without relying on fragile browser scripts, Shopify introduced Cart and Checkout Validation Functions. Running as compiled WebAssembly modules directly inside Shopify’s backend infrastructure, validation functions inspect the buyer’s email, phone number, name, shipping address, postal code, country, and customer tags on the server—rejecting risky checkouts before a payment processor is ever called.

In this technical and operational guide, we explain how Shopify Checkout Validation Functions stop fraud, how they replace legacy checkout.liquid and post-order filters, and how LabX Fraud Filter combines server-side checkout rules with storefront traffic controls. For a full overview of both protection layers, read our Shopify fraud prevention guide.

How does a Shopify Checkout Validation Function stop fraud before payment capture?

To understand why server-side checkout blocking on Shopify differs from older fraud tools, look at the sequence of events when a buyer clicks “Pay now” or advances through checkout:

  1. Buyer submits cart or checkout details: The shopper enters their email, phone number, and delivery address (or logs into a customer account) and attempts to progress.
  2. Shopify invokes the Validation Function on its servers: Before authorizing payment or creating an order record, Shopify executes registered cart.validations.generate.run functions inside a sandboxed server-side runtime.
  3. Structured GraphQL input is evaluated against compiled rules: Shopify passes the function cart.buyerIdentity (email, phone, and customer tag matches) and cart.deliveryGroups (first name, last name, phone, street address, ZIP/postal code, and country code), along with the app’s rule configuration stored in a reserved validation metafield.
  4. Validation errors halt checkout progression: When a rule matches, the function returns a ValidationAddOperation with one or more ValidationError objects. Shopify displays your custom error message inside the native checkout UI and blocks payment submission.

Because the order is stopped at step 4, payment authorization and capture never happen—no inventory is deducted and no payment processing fee is charged.

How do Shopify Functions compare to checkout.liquid, Script Editor, and post-order filters?

Before Shopify Checkout Extensibility, merchants had limited options for pre-payment filtering. Shopify Plus stores injected JavaScript into checkout.liquid or wrote Ruby scripts in the legacy Script Editor, while non-Plus stores waited until an order was placed and cancelled it using post-order workflows or Shopify Fraud Analysis.

Comparing Shopify Functions vs checkout.liquid for fraud shows why Shopify moved checkout logic to server-side WebAssembly functions:

ApproachWhere Logic ExecutesBlocks Before Payment Capture?Can a Buyer Bypass It?Maintenance & Upgrade Impact
Legacy checkout.liquid JS (Deprecated)In the buyer’s browser DOMVisually onlyYes—disabling JS, editing DOM elements, or calling APIs bypasses browser checksHigh; broke checkout upgrades and required manual template edits
Legacy Script Editor Ruby (Deprecated)Server-side during checkout (Plus only)Partial (line items, shipping, and gateway hiding)NoDeprecated in favor of Shopify Functions
Post-Order Cancellation (Flow / Legacy Fraud Filter)Server-side after order creationNo—runs after authorization or payment captureN/A (order already completed)Low, but merchants lose non-refundable gateway fees on captured orders
Storefront App Embed (Fraud Guard)In the visitor’s browser on storefront pagesStops casual visitors before they browse or add to cartYes—disabling JS or calling Cart APIs directly bypasses storefront scriptsLow; managed via Theme App Extension
Cart & Checkout Validation FunctionServer-side on Shopify’s checkout infrastructureYes—rejects matching orders before payment is submittedNo—enforced by Shopify on every cart and checkout progressionLow; upgrade-safe, sandboxed WebAssembly execution

As detailed in our comparison of Shopify Fraud Filter alternatives, relying on post-order cancellation when your store uses automatic payment capture means every cancelled order still costs you the payment processor’s transaction fee. Moving those rules into a Checkout Validation Function stops the loss before authorization.

Why can’t a Checkout Validation Function replace storefront traffic blocking on its own?

A common question from merchants is: “If a Checkout Validation Function runs server-side and cannot be bypassed, why do I still need a storefront blocker?”

The answer lies in what data Shopify passes into the cart.validations.generate.run GraphQL input query. A Cart and Checkout Validation Function is deterministic and isolated. It receives:

  • Buyer identity: email, phone, and whether the logged-in customer carries specific account tags (hasTags).
  • Delivery address: firstName, lastName, phone, address1, zip, and countryCode.

Notice what is not inside a Checkout Validation Function’s input: the visitor’s IP address, CIDR subnet, Autonomous System Number (ASN), ISP name, User-Agent header, referrer URL, Tor exit node status, or datacenter hosting flag. Furthermore, a checkout function only runs when someone interacts with the cart or checkout—it does not stop price scrapers, aggressive bots, or card testing attacks from probing your product catalog first.

That is why LabX Fraud Filter uses two separate rule lists:

  1. Storefront traffic and bot blocking (Fraud Guard app embed): Checks the visitor’s connection—IPv4/IPv6 addresses, CIDR blocks, countries, regions, ISPs/ASNs, devices, browsers, Tor exit nodes, datacenter traffic, and disposable emails on newsletter forms. Because Shopify serves storefront pages from its CDN, storefront rules run in the browser and can be bypassed if a visitor disables JavaScript.
  2. Checkout Protection (Shopify Cart & Checkout Validation Function): Checks the data the buyer typed into checkout (or their customer account tags) on Shopify’s servers, which cannot be bypassed from the browser or via direct Cart API calls.

What buyer fields and match modes can you enforce server-side at checkout?

Inside LabX Fraud Filter, Checkout Protection compiles your enabled rules into a JSON metafield attached to the store’s Validation object ($app:sam-fraud / checkout-rules). Before publishing, the app normalizes every value—trimming whitespace, lowercasing text fields, uppercasing ISO country codes, and stripping formatting characters from phone numbers—so the compiled Rust function spends its instruction budget purely on fast comparisons.

You can configure independent checkout rules across these conditions:

ConditionMatch Modes SupportedHow Server-Side Matching WorksCommon Fraud & Operations Use Cases
EmailExact match, ContainsCase-insensitive check against cart.buyerIdentity.emailBlock repeat chargeback emails or disposable domains (@mailinator.com, @tempmail.com, @yopmail.com)
PhoneExact match, ContainsStrips all non-digits (+, -, spaces, parentheses) and compares pure digits from buyer identity or shipping addressStop fake Cash-on-Delivery (COD) phone strings (0000000000) or repeat abusive numbers regardless of formatting
NameFirst Name, Last Name, or Full Name (Exact match / Contains)Case-insensitive check against firstName, lastName, or combined firstName lastName on the delivery addressReject automated bot test strings or repeat abuse aliases
CountrySelected target countriesMatches uppercase ISO countryCode on the shipping addressBlock checkouts shipping to unsupported or restricted countries
ZipExact match, ContainsCase-insensitive match against deliveryAddress.zipPrevent orders to unserviceable postal codes or high-dispute ZIP prefixes
Customer tagBuyer has any of these tags, Buyer has none of these tagsQueries customer.hasTags via Shopify input variables (up to 100 tags)Block accounts tagged chargeback (any mode), or restrict checkout to vip / wholesale accounts (none mode, which also blocks untagged guests)

The validation function also evaluates checkout progression in stages: because buyers fill in checkout forms step by step, a rule targeting a field the shopper has not yet entered waits until that field is populated rather than firing early.

How do inline field errors and fail-open safeguards protect conversion rates?

When you build rules in Checkout Protection (see our step-by-step Checkout Protection user guide), two architectural features protect real shoppers from friction or lockouts:

1. Targeted Error Placement (Top of checkout vs Next to the field)

Every checkout rule lets you write a custom error message up to 255 characters (or click a condition-specific preset) and choose where Shopify displays it:

  • Top of checkout ($.cart): Shows a banner at the top of checkout. This is ideal for account-level restrictions and is always used for Customer tag rules, since customer tags do not have an input field on the form.
  • Next to the field that triggered the rule (inline): Attaches the error directly to the matching checkout field—such as $.cart.buyerIdentity.email, $.cart.buyerIdentity.phone, $.cart.deliveryGroups[0].deliveryAddress.firstName, lastName, countryCode, or zip—so legitimate buyers can immediately spot and fix a typo or unsupported postal code.

2. Multi-Layer Fail-Open Architecture

Locking real customers out of checkout due to a configuration error is worse than letting a suspect order through to manual review. LabX Fraud Filter enforces fail-open safeguards at three points:

  1. Non-blocking failure registration (blockOnFailure: false): When registering the validation function via Shopify’s GraphQL Admin API, the app sets blockOnFailure: false so an unexpected runtime error never blocks checkout.
  2. Defensive Rust parser: If the configuration metafield is missing, empty, invalid JSON, or tagged with an unknown schema version, the function defaults to an empty rule list and returns zero errors.
  3. Pre-publish size guard: Because Shopify silently drops oversized function metafields, the app verifies that your compiled checkout ruleset stays within a 64,000-byte limit (up to 100 checkout rules and 100 values per rule) before publishing.

How can you deploy server-side checkout rules on your store today?

Setting up pre-checkout validation alongside your storefront rules takes less than ten minutes:

  • Open Checkout Protection in LabX Fraud Filter: Navigate to Checkout Protection in the app menu and click Add rule.
  • Block disposable email domains first: Select Email with Contains match mode, click the quick-add chips (+ @mailinator.com, + @tempmail.com, + @guerrillamail.com, + @10minutemail.com, + @yopmail.com), and set the error position to Next to the field that triggered the rule.
  • Add your historical chargeback and COD abuse identifiers: Create rules for repeat offending email addresses, placeholder phone numbers (remembering that phone matching compares digits automatically), and unserviceable ZIP/postal codes or countries.
  • Set up customer tag blocks (optional): If you tag problem accounts in Shopify Admin, create a Customer tag rule using Buyer has any of these tags. The app only requests the read_customers permission if and when you save a customer tag rule.
  • Verify your storefront layer is active: Enable the Fraud Guard app embed in your theme and review our guide on blocking VPN, Tor, and datacenter traffic on Shopify so automated bots are filtered before they even reach your cart.

Frequently asked questions

Can a buyer bypass a Shopify Checkout Validation Function by disabling JavaScript?

No. Cart and Checkout Validation Functions run server-side on Shopify infrastructure rather than in the visitor browser. Even if a buyer disables JavaScript, uses an ad blocker, or submits requests directly to the Cart or Checkout API, Shopify evaluates the validation function before allowing the checkout to proceed.

Why cannot a Checkout Validation Function block visitors by IP address or ASN directly?

Shopify Cart and Checkout Validation Functions receive a deterministic GraphQL input containing cart, buyer identity, customer tags, and delivery address fields, rather than raw network headers like IP address or ASN. To filter by IP, CIDR range, Tor exit node, or datacenter ASN, pair checkout validation with a storefront theme app embed.

What happens at checkout if a validation ruleset is malformed or fails?

In LabX Fraud Filter, checkout validation is built to fail open at two levels. The validation registration sets blockOnFailure to false on Shopify servers, and the compiled Rust function returns zero validation errors if its metafield configuration is missing or unreadable, ensuring legitimate buyers are never locked out.

Does server-side checkout blocking prevent non-refundable payment gateway fees?

Yes. Because a Checkout Validation Function returns a blocking error before payment authorization and capture occur, rejected checkout attempts never reach your payment processor and never incur non-refundable gateway transaction fees.

Sources

  1. Shopify Dev Docs — About Cart and Checkout Validation Functions
  2. Shopify Help Center — Fraud Analysis
  3. Shopify Help Center — Payment Authorization and Capture

Part of our guide: Shopify fraud prevention →

Put your first blocking rule live in minutes

Install LabX Fraud Filter free on Shopify, turn on the Fraud Guard embed and add your rules.

Install free on Shopify

Free plan available