Shopify GraphQL Admin API 2026‑04 Adds Multiple Product Discount Stacking on a Single Cart Line — What Merchants Need to Know Before the Scripts Sunset

Table of Contents

1. Key Highlights
2. Introduction
3. What the 2026‑04 change actually delivers
4. Why this matters now: the sunset of Shopify Scripts and the migration imperative
5. Typical Script behaviors that discount combinations can replicate
6. Key concepts: discounts, automatic vs. code-based, and combination rules
7. A practical migration checklist
8. Designing effective combinability rules: principles and examples
9. Technical approach: creating and configuring combined discounts via GraphQL
10. Order of operations and calculation details
11. Handling features Scripts provided beyond discount stacking
12. Integration considerations: POS, sales channels, and apps
13. Observability: logging, analytics, and dispute resolution
14. Performance and scale concerns
15. Legal, tax, and accounting implications
16. Best practices and operational recommendations
17. Real-world migration case studies (hypothetical but illustrative)
18. Testing matrix: scenarios you must cover
19. Developer tools and resources
20. Common pitfalls and how to avoid them
21. Roadmap implications for app developers and partners
22. Governance: discount lifecycle and change control
23. Preparing customer service teams
24. Final operational checklist before full migration
25. FAQ

Key Highlights

• The GraphQL Admin API 2026-04 introduces support for applying multiple product discounts to a single cart line via new discount combination configuration (see DiscountAutomaticBasic.fields.combinesWith).
• Merchants still reliant on Shopify Scripts can use discount combinations to reproduce common script behaviors and should prioritize migration ahead of the June 30, 2026 Scripts sunset.
• Practical migration requires auditing current script logic, mapping to discount types and combination rules, thorough testing in development stores, and updating analytics and POS integrations.

Introduction

Shopify has extended the GraphQL Admin API in the 2026-04 release to allow multiple product discounts on the same cart line. That change matters because many merchants used Scripts to implement discount stacking, complex pricing logic, and bespoke cart behavior. With Scripts scheduled to be retired on June 30, 2026, the new discount combination support in the GraphQL Admin API becomes a key tool for merchants and app developers migrating their custom discount logic.

This article explains what the change enables, how merchants and developers should approach migration, and how to design, test, and operate combined discounts reliably. Practical examples and technical guidance show how common Scripts use cases—loyalty discounts stacked with promotions, manufacturer coupons plus store markdowns, or tiered discounts—can be re-created using the Discounts API and its combination controls.

What the 2026‑04 change actually delivers

The 2026-04 GraphQL Admin API update exposes configuration for discount combinations through fields such as DiscountAutomaticBasic.fields.combinesWith. That lets administrators and API clients specify which discounts may apply together on a single cart line.

The functional effect is straightforward: where previously a single cart line could be altered by one discount rule (or where developers relied on Shopify Scripts to manipulate multiple discounts or override order items), the Admin API now supports stackable product discounts by explicit configuration. This removes a major migration blocker for many merchants who used Scripts to enable stacking of loyalty discounts, promotional offers, and automatic markdowns.

This release does not replace all Script capabilities. Scripts offered broader control over cart manipulation, shipping, payments, and fulfillment workflows. The discount combination feature focuses on product-level discount stacking, enabling many—but not all—discounting behaviors that Scripts previously implemented.

Why this matters now: the sunset of Shopify Scripts and the migration imperative

Shopify’s specified sunset of Scripts on June 30, 2026 establishes an immovable deadline for merchants and partners. Stores still running business-critical logic inside Scripts must migrate that logic to supported APIs and platform primitives. Several factors make the new discount stacking support timely:

• Business continuity: Merchants that stop using Scripts without alternatives risk losing discount behavior that customers expect—affecting conversion and customer experience.
• Feature parity: The ability to apply multiple discounts to the same cart line addresses a common gap encountered during early migration attempts.
• Developer roadmap: App builders can now create migration tooling and new discount-management products that rely on the Admin API’s combinability controls.

Merchants should treat the sunset as a hard deadline, but the practical work of migration can be time-consuming: auditing existing Scripts, defining equivalent discount configurations, implementing them via API or admin UI, and validating behavior across checkouts, POS, and channels.

Typical Script behaviors that discount combinations can replicate

Scripts grew popular because they allowed flexible, code-driven logic in checkout and cart. Not every Script will translate directly into discount combinations, but many common patterns map well:

• Stacked percentage discounts: A site that applied a site-wide sale plus a loyalty/member percentage discount per item can recreate that stacking by configuring which automatic discounts combine and applying one as an automatic sale and the other as a customer- or tag-based discount.
• Coupon plus automatic sale: Customers use a coupon code while automatic sales are active. With combinability rules, developers can allow a discount code to combine with an automatic product discount when appropriate.
• Quantity-based item discounts plus promotional percent: Scripts often applied "Buy 3 get 1 free" or volume pricing that also combined with a promo percent. Volume discounts often map to tiered or buy-X-get-Y discount types, and the new combinability controls let a volume discount coexist with a promo percent on the same line.
• Loyalty point redemption plus product markdown: Point-redemption systems that reduce per-item price can be combined with temporary markdowns if both are configured to combine.
• Manufacturer coupons: Retailers that accept manufacturer coupons plus store promotions can implement manufacturer coupons as discount codes or a specialized discount, then set combinesWith rules to permit stacking.

Each mapping requires careful attention to rounding rules, application order, quantity handling, and whether discounts apply to the same price component (unit price, line price, shipping, taxes).

Key concepts: discounts, automatic vs. code-based, and combination rules

Understanding how discounts are modeled in the platform helps in migration planning.

• Discount types: Discounts typically arrive as automatic discounts (applied without customer action), discount codes (redeemed at checkout), or app-created discounts via the Admin API. Types include percentage-off, fixed-amount-off, buy X get Y (free items), tiered pricing, and shipping discounts.
• Targeting: Discounts may target specific products, collections, customers, customer segments, or entire orders.
• Application granularity: Some discounts apply per-unit, some per-line, some per-order. The change highlighted in 2026-04 concerns product discounts applied to a cart line, allowing multiple such discounts to coexist.
• combinesWith: The new combinesWith configuration lets store owners and API clients specify which discounts are allowed to apply together. This can include toggles for combining with other automatic discounts, codes, or specific discount IDs, depending on the schema.

Designing combinability requires decisions about fairness (do you allow customers to stack all discounts?) and technical consistency (how will you calculate totals if multiple discounts apply?).

A practical migration checklist

Migrating from Scripts to the Discounts API should follow a disciplined plan. The checklist below organizes the main steps:

1. Inventory existing Scripts
   • Extract each Script’s purpose, conditions, and the outputs it produced (which discounts, how prices were changed, shipping/payment logic).
   • Note any edge cases, such as per-line overrides, custom rounding, or customer-account-dependent outcomes.
2. Categorize behaviors
   • Discount-equivalent: Straightforward discount transformations (percentage, fixed, buy X get Y) that can be recreated with the Discounts API.
   • Non-discount logic: Things Scripts handled that are outside discount scope (e.g., altering shipping methods, payment gateway logic). These require alternative approaches.
   • Hybrid behaviors: Scripts that combined discounting with other effects. Plan separate implementations for discounting and the remaining parts.
3. Map Script logic to discount constructs
   • For each Script behavior, select the appropriate discount type, scope (product/collection/order), and targeting rules.
   • Determine whether the stacked behavior requires multiple discount objects and whether they should be configured to combine.
4. Define combinability rules
   • Use combinesWith to allow or block stacking between discounts.
   • Test scenarios where multiple discounts apply to the same product, ensuring price calculation matches expectations.
5. Build and test in development environments
   • Use development stores and test checkouts to validate behavior end-to-end.
   • Include tests for customer account states, loyalty tiers, and coupon redemption.
6. QA and edge case testing
   • Rounding and currency precision.
   • High-quantity orders and bulk discounts.
   • Interaction with taxation and shipping discounts.
7. Roll out and monitor
   • Deploy in controlled phases where possible (A/B testing, select customer segments).
   • Monitor conversion, average order value, and error reports.
8. Update operational docs and dashboards
   • Reflect new discount definitions in internal documentation.
   • Update analytics pipelines to capture discount attribution.

Designing effective combinability rules: principles and examples

Combinability is both a technical and a business decision. Good rules ensure predictable pricing, prevent abuse, and preserve margin.

Principles:

• Explicitness: Make combination rules explicit rather than implicit. That simplifies testing and communication across teams.
• Minimal surprise: Customers should never see unexpected discounts. Clear storefront messaging helps.
• Prioritization: Establish which discounts take precedence when overlaps cause conflicts or when maximum-cumulative discounts exist.
• Auditability: Keep records of which discounts applied and why, facilitating post-order reconciliation.

Examples:

Example 1 — Apparel retailer (seasonal sale + loyalty discount)

• Business rule: Customers receive a 20% seasonal discount on select collections. Loyalty members receive an additional 10% on the same items.
• Implementation: Create an automatic product discount for the seasonal sale. Create a second discount targeted to customers with the loyalty tag. Configure combinesWith so the loyalty discount and the seasonal sale combine on the same product lines. Ensure the system applies the loyalty discount to the already-discounted price or the pre-discount price, per business rules, and document ordering.

Example 2 — Grocery store (manufacturer coupon + store promotion)

• Business rule: Manufacturer coupons (entered as discount codes) may be used together with store-level promotions but not with other manufacturer coupons.
• Implementation: Represent manufacturer coupons as code-based discounts and set their combinesWith to allow stacking with automatic store promotions but to block other manufacturer code discounts. Implement server-side validation to ensure coupon meta-data (manufacturer ID) prevents stacking with same-manufacturer coupons.

Example 3 — Electronics seller (bundle discount + promo code)

• Business rule: A bundle discount applies a fixed-dollar reduction when specific SKUs are purchased together. Promo codes apply a percentage off the item price but should not reduce the bundle discount amount.
• Implementation: Configure the bundle as a buy-X-get-Y or bundle discount targeting the exact SKUs. Create the promo code with combinesWith set to allow stacking but design the calculation so the promo percent applies to the unit price after bundle allocation rules. If that's not feasible, implement a promotion that only applies where the bundle discount is not active, or vice versa.

Each example requires validation of math and display: ensure customers see line-level breakdowns that match the backend calculations.

Technical approach: creating and configuring combined discounts via GraphQL

The 2026-04 GraphQL Admin API exposes fields to configure whether discounts can combine. The documentation entry DiscountAutomaticBasic.fields.combinesWith is the central point for configuring combination behavior for an automatic discount.

Conceptual GraphQL flow (illustrative):

• Create an automatic product discount via the Admin API.
• When creating or updating, include the combinesWith field and list which discount categories or IDs are allowed to combine.
• Create any companion discounts (coupon codes, volume discounts) and configure their combinesWith settings reciprocally if required.

Sample (illustrative pseudocode GraphQL mutation) Note: This snippet is illustrative. Use the official API schema and documentation for exact fields and types.

mutation { discountAutomaticBasicCreate(input: { title: "Seasonal 20% Off", startsAt: "2026-05-01T00:00:00Z", endsAt: "2026-06-30T23:59:59Z", targets: [{ productIds: ["gid://shopify/Product/123"] }], value: { percentage: 0.20 }, combinesWith: { automaticDiscounts: true, discountCodes: false, specificDiscountIds: ["gid://shopify/DiscountAutomatic/456"] } }) { discount { id title combinesWith { automaticDiscounts discountCodes specificDiscountIds } } userErrors { field message } } }

This example demonstrates key ideas: specifying targets, setting value, and configuring combinesWith. The actual field names and types should be verified against the current GraphQL schema.

Testing via API:

• Query the discount object after creation to confirm combinesWith rules.
• Simulate a checkout or use checkout APIs to apply combinations and verify final calculations match expected totals.

Notes on reciprocal configuration:

• Some implementations require both discounts to be configured to combine. Define whether combinesWith is directional (only one discount needs to allow combining) or mutual in your rules and test accordingly.
• Implement server-side assertions if business rules demand stricter control (for example, deny combination unless both discounts explicitly allow it).

Order of operations and calculation details

Stacking multiple discounts on a single line raises calculation questions:

• Sequential application vs. independent calculation: Are stacked discounts applied one after another (discount on the already-discounted price) or calculated independently on the original price and then summed?
• Rounding rules: Multi-discount scenarios often produce fractional cents. Decide on rounding policy—per-line, per-unit, or final order total—and be consistent.
• Tax calculation: Discounts may affect taxable amount. Determine whether taxes are recalculated after each discount step and how tax rounding interacts.
• Maximum discount caps: Some businesses cap total discounts. Add guards to ensure cumulative discounts never exceed configured thresholds.

Design choices:

• If business logic requires "best price" selection rather than additive discounts, implement logic to calculate all variant totals and select the best for the customer.
• For multi-currency stores, apply rounding per currency rules and ensure currency conversion does not introduce leakages.

Tests to run:

• Unit tests that compute discount outcomes for each combination.
• Integration tests that simulate checkout with multiple discounts and confirm display and backend totals match.
• Edge case tests for large quantities, fractional discounts, and multi-currency.

Handling features Scripts provided beyond discount stacking

Scripts often touched areas beyond per-line discounts. Plan alternative implementations:

• Shipping logic: Scripts could alter shipping options or rates. Use Shopify Shipping settings, carrier service integrations, or checkouts API features to approximate behavior. If dynamic shipping rates remain essential, consider a carrier-calculated shipping app or the CarrierService API.
• Payment flow: Scripts sometimes restricted available payment methods. Use payment provider settings or custom payment apps where platform features support it.
• Per-line fulfillment or inventory manipulations: Leverage webhooks, fulfillment orders API, or fulfillment services to approximate pre-checkout adjustments.
• Custom UI/UX changes: Some Scripts changed cart presentation. Implement client-side logic in storefront code or via app-proxies to replicate display-level adjustments.

Document remaining gaps where Scripts provided unique capabilities and prioritize these based on business impact.

Integration considerations: POS, sales channels, and apps

Stacked discounts must behave consistently across sales channels.

Point of Sale (POS):

• Ensure POS systems fetch latest discount rules from the Admin API or a centralized config store.
• Offline POS behavior: If POS devices operate offline, pre-download discount rules or limit discounts based on online availability.
• Receipt and register display: Adjust receipt formatting to show multiple discount lines clearly.

Third-party apps:

• Inventory and fulfillment apps rarely need to know discount details, but analytics, accounting, and tax apps must capture discount attribution.
• Notify any app that previously read Scripts for discount logic to read new discount configs or be updated to compute discounts themselves when necessary.

Sales channels:

• Marketplace syncs and marketplaces with their own discounting may require mapping rules to keep pricing consistent.
• Ensure storefront scripts, theme code, and Shopify Functions (if applicable) align with discount behavior displayed to the customer.

Observability: logging, analytics, and dispute resolution

When multiple discounts can combine, clear attribution and traceability become critical.

Logging:

• Log which discounts applied to each order and which combination rules triggered.
• Capture pre- and post-discount values with timestamps and discount IDs.

Analytics:

• Track coupon redemption rates, stack frequency, average discount per order, and margin impact.
• Use this data to refine combinability rules and promotional strategies.

Dispute resolution:

• Keep human-readable explanations in order history and admin UI showing how final prices were derived.
• Provide order-level records that support customer service queries about discounts.

Retention of logs:

• Maintain logs and discount snapshots for at least the period required for returns, chargebacks, or audits, typically months to years depending on business and jurisdiction.

Performance and scale concerns

Applying multiple discounts per cart line increases computation during checkout. Plan for scale:

• Caching: Cache computed discount outcomes for identical cart compositions where appropriate.
• Validation at creation: Validate discount rules at creation time to avoid runtime conflicts that generate heavy error-handling loads.
• Throttling and rate limits: Respect API rate limits when programmatically creating or updating many discounts.
• Batch testing: Run load tests simulating peak checkout traffic to ensure discount calculations do not add unacceptable latency.

Platform limits:

• Verify any platform limits around the number of discounts per shop, per line, or per checkout request.
• Optimize discount definitions using product collections or tags rather than creating many product-specific discounts when possible.

Legal, tax, and accounting implications

Stacking discounts affects reported revenue, tax calculations, and promotions accounting.

Taxation:

• Ensure tax calculations are consistent with local tax law. Discounts applied before or after tax affect tax owed differently in some jurisdictions.
• For exempt items, verify that stacked discounts don’t unintentionally alter tax status.

Accounting:

• Record discounts distinctly in accounting systems for promotion expense analysis.
• Provide invoice-level breakdowns that allow accountants to reconcile discounts, returns, and chargebacks.

Consumer protection and advertising:

• If advertised discounts are conditional on stacking, ensure marketing copy accurately reflects the final price.
• Avoid misleading statements about "up to" or "additional" savings unless fully supported by pricing examples.

Compliance:

• Some promotions must be disclosed or cannot be stacked under consumer law. Legal review should validate major promotional campaigns.

Best practices and operational recommendations

Adopt practical rules that make discount stacking manageable and predictable.

• Start small: Pilot stacking behavior on a subset of products or a single store before wider roll-out.
• Use tags and collections: Target discounts using tags or collections to reduce the number of discount objects.
• Implement defensive guards: Prevent runaway discounts by setting maximum cumulative discounts per order or per product.
• Make stackability explicit in the UI: Display each applied discount clearly on cart and checkout pages with brief explanations.
• Maintain a single source of truth: Centralize discount configuration in a service or admin flow, and avoid ad-hoc changes directly in multiple places.
• Monitor and iterate: Use analytics to refine which combinations increase margin and which erode it.

Real-world migration case studies (hypothetical but illustrative)

Case study A — Mid-size fashion retailer Situation: The retailer used multiple Scripts to apply member-exclusive prices stacked with seasonal promotions and flash discounts. Scripts also handled gift wrap fees and shipping adjustments. Approach:

• Catalogued Script behaviors and prioritized discount-equivalent features.
• Recreated member-exclusive price via a customer-tag-based automatic discount and allowed stacking via combinesWith.
• Implemented the selection of shipping adjustments using Shipping Rate APIs and shipping rule configuration. Outcome:
• The retailer preserved most customer-facing discount behavior. Gift wrap and other non-discount features were ported to theme customization and backend fulfillment rules.

Case study B — Subscription box company Situation: Complex rules: first-box discount, referral credits, and promotional codes sometimes applied simultaneously. Approach:

• Mapped first-box discounts to subscription product promotions and ensured renewal pricing tracked expected values.
• Represented referral credits as store credit applied at checkout using a combination of discount code and customer account deductibles, with combinesWith settings preventing double-application. Outcome:
• Referral and promo stacking behavior matched prior Scripts behavior. Renewals remained unaffected by checkout-only discounts due to careful scoping.

These case studies demonstrate that while migration can be involved, careful decomposition of Script behaviors enables equivalent results through the Admin API and complementary platform features.

Testing matrix: scenarios you must cover

Create a testing matrix to ensure robust coverage.

Essential scenarios:

• Single discount applied to one product (baseline).
• Two discounts that are configured to combine.
• Two discounts configured to not combine (ensure exclusivity).
• Three or more discounts stacking together (test order of operations and rounding).
• Discount code applied with automatic discounts.
• Quantity- and tier-based discounts combined with percent or fixed discounts.
• Multi-currency checkout with exchange rate rounding.
• Tax-exempt and taxable items with discount stacking.
• POS checkout applying the same discount set.
• Refunds and partial returns that affect stacked discounts.

For each scenario, verify:

• Visible line-item breakdowns.
• Backend order totals and tax amounts.
• Audit logs that capture discount IDs and applied amounts.
• Customer experience in storefront and confirmation emails.

Developer tools and resources

Developers should rely on the official GraphQL Admin API documentation and the DiscountAutomaticBasic.fields.combinesWith entry for exact schema. Use development stores and API clients for sandbox testing.

Tools:

• GraphiQL or other GraphQL clients for experimenting with mutations and queries.
• Automated test frameworks for end-to-end checkout flows.
• Monitoring and observability tools for runtime telemetry.

If your organization uses CI/CD, include discount configuration tests in pull requests to prevent regressions.

Common pitfalls and how to avoid them

• Overcomplicated stacking rules: Keep rules as simple and few as possible. Complexity multiplies edge cases.
• Assuming symmetry: Don’t assume combinesWith is symmetric—test whether both discounts need allowances or only one.
• Ignoring rounding: Small differences due to rounding can produce mismatched totals at scale. Define consistent rounding policies.
• Not adapting UI: Customers confused by discount breakdown will contact support. Ensure frontend reflects backend decisions.
• Last-minute migration: Migration requires significant testing; start early and avoid cutting it close to the June 30, 2026 sunset.

Roadmap implications for app developers and partners

App developers who previously extended Scripts have new opportunities and responsibilities:

• Build migration tools that parse Scripts and recommend discount configurations and combinations.
• Offer UI components for merchants to visualize and manage combinability rules.
• Ensure apps that impact pricing, loyalty, or promotions integrate with the Admin API’s combinesWith logic.
• Communicate migration timelines and assist merchants with testing and rollout.

Partners should prioritize high-impact merchants—those with complex promotional setups or large order volumes—to minimize revenue disruption.

Governance: discount lifecycle and change control

Promotions and discounts rapidly evolve. Implement governance to control change:

• Change approval: Require sign-off for discount changes above a defined impact threshold.
• Versioning: Treat discount configurations like code—maintain change history and versioning where feasible.
• Rollback: Plan and test rollback paths for discount changes that generate unexpected revenue or legal exposure.
• Scheduling: Use start and end times on automatic discounts to avoid accidental long-running promotions.

Governance reduces risk from misconfigured combinability rules and unexpected stacking.

Preparing customer service teams

Customer service teams must understand stacked pricing to resolve queries quickly:

• Provide training modules that explain common discount stacks and how totals are derived.
• Create lookup tools for CSRs that display discount IDs and breakdowns for each order.
• Include scripted explanations for common questions (why my loyalty discount didn't apply; why my coupon didn’t further reduce the sale price).

A well-informed support team reduces friction and improves customer trust.

Final operational checklist before full migration

• Confirm all discount-equivalent Script behaviors have mapped implementations.
• Validate all combinesWith configurations and their symmetrical behavior.
• Complete the testing matrix with edge cases and load tests.
• Update POS and channel integrations for consistent discount behavior.
• Communicate customer-facing changes and promotional rules in advance.
• Clear support documentation and staff training completed.
• Establish monitoring and rollback plans.

Deploy in stages when feasible and monitor key business KPIs: conversion rate, average order value, and discount burn.

FAQ

Q: What exactly changed in the GraphQL Admin API 2026‑04 release? A: The 2026-04 release added support for applying multiple product discounts on a single cart line via discount combination configuration. The DiscountAutomaticBasic.fields.combinesWith field is a documented entry point for configuring which discounts may combine.

Q: Does this change eliminate the need to migrate Scripts? A: No. This change addresses a common Scripts use case—stacking product discounts on a single cart line—but Scripts cover broader checkout capabilities, including shipping, payments, and custom cart logic. Merchants must still migrate or re-implement any non-discount behavior previously implemented with Scripts before the June 30, 2026 sunset.

Q: How do combinesWith rules behave? Do both discounts need to agree to combine? A: Behavior depends on platform semantics and how the combinesWith field is interpreted in the current API. Some configurations require mutual allowance while others treat combinesWith as allowing other discounts to apply. Test your specific combination rules in a development store and consult the GraphQL Admin API documentation for exact semantics.

Q: Can promo codes combine with automatic discounts? A: The API now supports configuring which discounts may combine. Whether a promo code combines with an automatic discount depends on the combinesWith settings for the involved discounts. Implement combinations deliberately and test promo-code-plus-automatic scenarios.

Q: Will stacking discounts affect tax calculations? A: Discount stacking affects taxable amounts. Ensure tax calculations and rounding policies are handled consistently and comply with jurisdictional requirements. Consult tax advisors for complex scenarios.

Q: Are there limits to how many discounts can stack on a single line? A: Platform limits may exist. Verify shop-level limits, the Admin API schema, and performance considerations. Design discount definitions to be efficient and test behavior at scale.

Q: What steps should merchants take now to prepare for the Scripts sunset? A: Inventory Scripts, map Script logic to Discounts API and other platform features, configure combinesWith rules where needed, run comprehensive tests, update POS and app integrations, train support staff, and roll out changes in controlled phases before June 30, 2026.

Q: Where can I find more technical details? A: Refer to the GraphQL Admin API documentation entry for DiscountAutomaticBasic.fields.combinesWith and related discount mutation and query documentation. Use development stores and API clients to test configuration and behavior.

Q: Will my customers notice changes? A: If migration is implemented correctly, customers should see identical or improved discount behavior. Communicate any intentional changes to promotional stacking rules to avoid surprises.

Q: Can third-party apps help with migration? A: Yes. Partners and apps can assist by translating Script logic into discount configurations, providing UI for managing combinability, and offering monitoring and testing tools.

Q: What should I do if a discount stacking rule causes unexpected discounts or losses? A: Implement quick rollback procedures, revoke or pause problematic discounts, and use audit logs to trace orders affected. Update governance and testing to prevent recurrence.

Q: Are there best practices for presenting multiple discounts to customers? A: Display each applied discount line-by-line on cart and checkout pages, include short explanations, and show both original and final prices. Clear presentation reduces customer confusion and support overhead.

Q: Who should I contact if I need migration help? A: Start with platform documentation and partner developers familiar with Shopify migrations. For complex enterprise scenarios, engage certified partners or consultants with experience migrating Scripts to the Discounts API and related platform features.

---

The GraphQL Admin API’s addition of discount combination controls is a meaningful step toward feature parity for common Scripts-driven discount behaviors. Merchants and developers must still balance technical implementation with business rules, governance, and careful testing. Start the migration work now, prioritize high-impact Scripts, and use the new combinesWith configuration to recreate predictable, auditable, and customer-friendly discount stacking ahead of the June 30, 2026 sunset.