You can now specify the category-related features your app offers for 30 additional categories. Fill out the fields on your app listing pages so that merchants can more easily find and assess whether your app meets their needs. These structured app category details will appear on your App Store listing page and in the app comparison feature.

• Countdown timer
• Metafields
• Forms
• Navigation and menus
• Wishlists
• ERP
• Accounting
• Taxes
• Legal
• Wholesale
• Returns and exchanges
• Geolocation
• Stock alerts
• Pre-orders
• Web push
• Gift cards
• Donations
• Gift wrap and messages
• Giveaways and contests
• Surveys
• Image gallery
• Third-party logistics (3PL)
• Fraud
• Helpdesk
• FAQ
• Delivery and pickup
• Video and livestream
• Event booking
• Accounts and login
• Cash on delivery (COD)

For the other categories that already supports app feature details, see here and here. We plan to support all categories by August 2024.

For more information, please refer to our dev documentation.

The shipping and billing address forms in checkout can now have street name, street number, and neighborhood fields, allowing merchants to collect address data in regionally-accepted formats. The fields that are available depend on the country selected at checkout and if a merchant has additional address fields enabled. You can review the supported countries in the help documentation.

The fields are now available for developers to test with as part of the Checkout Extensibility developer preview. The change will be rolling out to merchants in the coming weeks.

Learn how to make use of this data on Shopify.dev.

We are removing the "All count name are in your cart." error response in favour of the exisiting "You can't add more name to the cart." error response in the Cart Ajax API.

Old behaviour: - When all inventory of a variant are already in the cart and the client requests to add more of that variant to the cart, the error response description is "All count name are in your cart.", and the message is "Cart Error". - When some of the inventory of a variant is in the cart and the client requests to add more of that variant to the cart, so that the total amount in the cart is more than the available inventory, the error response description and message is "You can't add more name to the cart."

New behaviour: - When the client requests to add more than available inventory of a variant already in the cart the error response description and message is "You can't add more name to the cart."

This will affect the update.js, change.js, and add.js endpoints.

We are rolling out changes to CAPTCHA on the following forms on Storefronts:

• Customer Login
• Customer Account Creation
• Reset Password
• Contact Form
• Newsletter Signup
• Blog Comments

The changes include:

1. Migration from Google reCAPTCHA to hCaptcha

We are migrating our CAPTCHA solution to hCaptcha as part of an ongoing effort to reduce form spam. This is an ongoing, phased, rollout, and does not affect our published methods for you to work with CAPTCHA.

2. Alternative methods to bind CAPTCHA to forms

You can now force CAPTCHA wireup to Storefront forms using either declarative markup or JavaScript. This is primarily intended for App/Theme developers who wish to take control of Form submission, for example by constructing hidden forms that POST to Shopify. See the documentation for further information and examples.

3. Strict CAPTCHA validation on form submissions

Previously, forms submitted from Storefronts that contained an invalid or missing CAPTCHA token would redirect to /challenge for the user to solve an interactive CAPTCHA. Such form submissions will now cause a 400 error. Theme and App authors who submit forms to Shopify are strongly encouraged to ensure that their forms work with CAPTCHA enabled, by submitting a valid CAPTCHA without relying on the redirect to /challenge

Orders with multiple shipping lines may be refunded. You can refund shipping amounts using the refundCreate GraphQL mutation, the returnRefund GraphQL mutation, or the Refunds REST API.

As of July 18, 2024, all Admin GraphQL API versions return accurate refunds data for orders with multiple shipping lines.

1. Shipping refunds will be included in the refundShippingLines connection, in addition to shipping lines removed via an order edit.
2. For each refunded shipping line, there will be an OrderAdjustment with kind SHIPPING_REFUND. Previously, there would be a single OrderAdjustment with kind SHIPPING_REFUND regardless of how many shipping lines were present on the order.
3. The RefundAgreement has multiple shipping line sales. Each ShippingLineSale corresponds to exactly one shipping line that was refunded. The ShippingLineSale.shippingLine is now populated for all API versions for the RETURN action type.

As of July 18, 2024, all REST API versions return accurate refunds data for orders with multiple shipping lines.

1. For each refunded shipping line, there will be an order adjustment with kind = shipping_refund in the order_adjustments property. Previously, there would be a single order adjustment with kind = shipping_refund, regardless of how many shipping lines were present on the order.

Please note that Refund.refundShippingLines and RefundAgreement.sales are only available in the Admin GraphQL API. They are not present in the Admin REST API.

In the version 2024-10 release of the Admin GraphQL API, we are making the following changes in the product delete APIs

• The productDeleteAsync mutation will be removed.
• A new synchronous boolean parameter will be added to the productDelete mutation, allowing you to choose whether the product deletion should be processed synchronously or asynchronously.

Key Updates:

• Asynchronous Deletion: By setting the synchronous parameter to false in the productDelete mutation, the operation will proceed asynchronously, returning a ProductDeleteOperation object.
• Operation Tracking: You can track the status of the asynchronous deletion by querying the operation ID through the ProductOperation query.

For more detailed information and examples, visit our ProductDelete documentation on Shopify.dev.

In the version 2024-10 release of the Admin GraphQL API, we are making the following changes in the product duplicate APIs:

The productDuplicateAsyncV2 mutation will be removed.

A new synchronous boolean parameter will be added to the productDuplicate mutation, allowing you to choose whether the product duplication should be processed synchronously or asynchronously.

Key Updates:

Asynchronous Duplication: By setting the synchronous parameter to false in the productDuplicate mutation, the operation will be performed asynchronously, returning a ProductDuplicateOperation object.

Operation Tracking: You can track the status of the asynchronous duplication by querying the operation ID through the ProductOperation query.

For more detailed information and examples, visit our productDuplicate documentation on Shopify.dev.

As of GraphQL Admin API version 2024-10 we're deprecating several singular variant mutations in favor of their bulk version, namely: * productVariantCreate. Use the productVariantsBulkCreate instead. * productVariantUpdate. Use the productVariantsBulkUpdate instead. * productVariantDelete. Use the productVariantsBulkDelete instead.

As of Juy 16th, the structured_data filter outputs product information using the ProductGroup schema.org type, according to the latest recommendations from Google.

As of the GraphQL Admin API version 2024-10, we're deprecating the GREATER_THAN_ZERO and INVALID_LINE_ITEM_QUANTITY error codes on the fulfillmentOrderReleaseHold mutation. These error codes are no longer returned by the mutation.

Hydrogen v2024.7.1 is out today. The July 2024 Hydrogen release contains several new features and bug fixes, including:

• A new useOptimisticVariant hook
• sellingPlanId support for <BuyNowButton />
• New customer account session commit pattern (breaking)
• <VariantSelector /> improved handling of options (breaking)
• Update Remix to 2.10.0 which included fixes to infinite loading error
• Type fixes for optimistic cart
• CLI: Vite bundle analyzer
• CLI: Support CSS options in Vite projects

Check out our full Hydrogen July 2024 release blog post for more details. And please drop your comments, feedback, and suggestions in GitHub Discussions!

We have introduced a new field, Product.restrictedForResource, which allows you to query product restrictions for a given CalculatedOrder resource. This field returns both the restricted status and the reason for the restriction.

Currently, this feature supports checking for Managed Markets product restriction. You can use this field to determine if a product can be added to a CalculatedOrder during the order edit mutation process.

The achievements section of the Distribution page in Partners Dashboard will be removed as of today. You will not lose the ability to see the status of your achievements as they are available in other places on the page.

You can see your Built for Shopify status in the same card above where the Achievement section was located.

You can see your highlight achievement status in the Technical criteria checklist section below.

As of 2024-10, the CartTransform create mutation will support metafields as an argument.

The new metafields argument for cartTransformCreate allows for metafields to be set for the CartTransform at creation without the need to call metafieldsSet in a subsequent call.

Learn more about the CartTransform API.

We have improved the design and function of Dynamic Checkout and Accelerated Checkout buttons on storefront pages. Checkout buttons now support Functions, provide better performance and a smoother user experience. Button styling has been enhanced, and skeletons have been added to prevent layout shifts during page loading. Some customized themes may be impacted by these UI updates as a result. These improvements are actively rolling out to merchants who have migrated to Checkout Extensibility.

Learn more about Accelerated Checkouts and Function APIs on Shopify.dev.

In the 2024-07 API version of checkout UI extensions, we have introduced a new instructions API. This API will inform checkout UI extensions when a particular extension API is/is not available for the current checkout. For example, if you intend to add a discount code via the applyDiscountCodeChange method, check discounts.canUpdateDiscountCodes to ensure it's supported in this checkout.

All checkout UI extensions updating to 2024-07 will be expected to review the list of APIs that may be restricted, and incorperate fail-safes if a particular API is not available in the current checkout. This will be required for checkout UI extensions to start rendering in draft order invoice checkouts.

For more details, please refer to our 2024-07 update guide for more details and instructions on how to safely update to 2024-07.

As of GraphQL Admin API version 2024-07, you can now set and query a customer's data sale / sharing opt out status. This allows customers to be opted out of data sale / sharing in support of compliance with US state laws like CCPA/CPRA. The Admin API now includes the following updates: * Set dataSaleOptOut: Set the data sale / sharing opt out status of a customer * Query dataSaleOptOut: Query the data sale / sharing opt out status of a customer

To learn more about data sale / sharing opt-outs, refer to the Shopify Help Center and the Customer Privacy API.

As of the 2024-07 release of the GraphQL Admin API, a new error code LEDGER_DOCUMENT_INVALID will be added to the potential errors for the InventorySetScheduledChanges mutation. This error code will be returned when the ledgerDocumentUri provided is not a valid URI.

As of 2024-07, you can use the Order.transactionsCount to return the number of transactions associated with a given order.

As of 2024-07, you can use the fileUpdate mutation to connect files to products.

Learn more about working with files on Shopify.dev.

As of 2024-07, a ProductVariant connection will be added to the FulfillmentOrderLineItem object in GraphQL.

This will allow order management apps to easily reference the specific product details that are related to each fulfillment order line item without needing to directly compare SKUs in the order line items.

Learn more about order management apps here.

As of GraphQL Admin API version 2024-07, you can now set available and on hand quantities for inventory via the new inventorySetQuantities graphql mutation. At the same time, the inventorySetOnHandQuantities mutation will be deprecated.

As of 2024-07 version, SellingPlan resources support metafields. Use metafields APIs to store additional information in metafield values.

You can use the sellingPlanGroupCreate mutation and sellingPlanGroupUpdate mutation to update and create metafields on the selling plan objects by specifiying the metafields field of sellingPlanInput.

To learn more about metafields, refer to the metafields documentation.

• As of GraphQL Admin API version 2024-07, the Product Set mutation will default to running synchronously unless the input parameter synchronous is set to false.
• As of GraphQL Admin API version 2024-07, the input limit on variants has been increased to the existing asynchronous limit. Versions prior to 2024-07 had a limit of 100 variants. Setting synchronous: false may be desirable depending on the input complexity/size, and should be used if you are experiencing timeouts.

As of 2024-07, the product create and update webhook payload contains information about the media on a product.

Using media GIDs allows compatibility with GraphQL Admin API mutations such as https://shopify.dev/docs/api/admin-graphql/2024-07/mutations/fileupdate and https://shopify.dev/docs/api/admin-graphql/2024-07/mutations/productupdatemedia

To receive media in the webhook payload, specify 2024-07 or greater as the webhook API version.

Stay informed with the latest enhancement to our orders/edited webhook payload! As of 2024-07, the webhook payload exposes the timestamp an order edit was committed at.

With this new attribute, you can precisely identify when an edit to an order is finalized, adding a new layer of clarity that was previously missing: created_at represents when the order edit was created, but not when it was persisted to the order.

We understand that navigating through multiple order changes can be daunting and are confident that the inclusion of committed_at will make a significant difference.

To receive this new attribute in the webhook payload, specify 2024-07 or greater as the webhook API version. You can find more details about the webhook here: Orders Edited Webhook Documentation.

As of 2024-07, we've added APIs for viewing and filtering conditional metafield definitions such as product attributes: * Use the constraints field on MetafieldDefinition to view the metafield definition's constraints. * Use the constraintSubtype argument on the metafieldDefinitions and standardMetafieldDefinitionTemplates queries to retrieve only metafield definitions that apply to the passed constraint subtype. * Use the constraintStatus argument on the metafieldDefinitions and standardMetafieldDefinitionTemplates queries to filter based on whether the metafield definitions are constrained.

Learn more about conditional metafields

As of 2024-07 in the GraphQL Admin API, you can use new return APIs to interact with exchange primitives.

The returnCreate mutation can now take exchange line items with optional discounts, return shipping fees and restocking fees to be applied to return lines. A return with exchange line items will also create a new FulfillmentOrder for the new items to be sent to the customer. Note that canceling a return does affect the fulfillment of exchange items. Read more on how exchanges are processed here.

The returnLineItemRemoveFromReturn mutation is now available to remove return lines from a return. With returns creating sales, removing a return line from a return will also reversely impact return sales.

The returnCalculate query is now available to calculate financials before return creation, including inputs for return lines, exchange lines, fees and discounts. Learn more about how to use this query in our dev docs.

As of 2024-07 in the GraphQL Admin API, Shopify’s suggestion for refund is inclusive of payable charges, such as exchange items and fees, alongside returns.

The Return.suggestedRefund query and ReturnRefund mutation APIs will now have a different expectation on the refund amount. The refund amount considers exchange line items and fees on the return, as well as any outstanding amount owed by the buyer on an order.

This affects the logic for 2024-07 versions and onwards, the logic for previous API versions will continue to only account for return line items.

Here is an example for an order with a return for an item worth $50.99 CAD and a return fee of $5 CAD, given this suggested return refund query:

query {
  return(id: "exampleReturn/1") {
    suggestedRefund(
      returnRefundLineItem: [
        {
          returnLineItemId: "exampleReturnLineItem/1"
          quantity: 1
        }
      ]
    ) {
      amount {
        shopMoney {
          amount
          currencyCode
        }
      }
    }
  }
}

Result with previous behavior

{
  "data": {
    "return": {
      "suggestedRefund": {
        "amount": {
          "shopMoney": {
            "amount": "50.99",
            "currencyCode": "CAD"
          }
        }
      }  
    }
  }
}

Result with new behavior:

{
  "data": {
    "return": {
      "suggestedRefund": {
        "amount": {
          "shopMoney": {
            "amount": "45.99",
            "currencyCode": "CAD"
          }
        }
      }  
    }
  }
}

Note that if the return fee was greater than $50.99 CAD, the suggested amount cannot be lower than $0 CAD.

As of the 2024-07 release of the GraphQL Admin API, the location object will be gated by the read_locations scope. Attempting to read the location object without the read_locations access scope will return an access denied error.

Starting in version 2024-07, the Return.returnLineItems connection becomes an interface type. This change is designed to accommodate more diverse return item types in the future, which will increase your flexibility in handling returns.

To maintain compatibility with existing implementations, adjust their queries to use an inline fragment, as shown in the example below. This adjustment ensures that queries will continue to function correctly with the new interface type.

returnLineItems(first: 30) {
  edges {
    cursor
    node {
      ... on ReturnLineItem {
        id
        ...ReturnLineItemAttributes
      }
    }
  }
}

As of GraphQL Storefront API version 2024-07, you can query bundles components and bundle parents on ProductVariant object.

This API change introduce three new fields on the ProductVariant object:

1. requiresComponents - A boolean field which is set to true when the variant can only be purchased as a parent bundle with components.
2. components - List of bundles components included in the variant considering only fixed bundles.
3. groupedBy - List of bundles that include this variant considering only fixed bundles.

Learn more about Bundles on Shopify.dev.

As of API Version 2024-07, the Product Discount Function API now supports a new target type: CartLineTarget, allowing for the application of discounts on specific cart lines, a use case that has historically only been possible with Shopify Scripts. This update can be used to link discounts to attributed cart lines such as upsell products, free gifts with purchase, or buyer customized products. You can learn more about the Product Discount Function API here.

As of GraphQL Admin API version 2024-07, you can create fixed bundles using our new coarse-grained API.

This API change introduces the following new mutations:

1. productBundleCreate mutation
2. productBundleUpdate mutation

Learn more about Bundles on Shopify.dev.

As of 2024-07, Cart#deliveryGroups supports a new withCarrierRates argument, used to indicate intent to fetch carrier-calculated rates. This capability requires mandatory use of @defer directive, which ensures that the cart response is not blocked on calculating rates.

Test out the carrier-calculated rates on the cart today by following our tutorial. We value your input, please share your feedback on Github.

As of version 2024-07 of the Admin GraphQL API, we're adding 14 new LocalizationExtensionsKey values to support the collection of tax / shipping credentials in several new countries.

Learn more about LocalizationExtensionKeys on Shopify.dev.

Changelog: Deprecation Notice for Country and Province Endpoints

Version: 2024-07

As of the 2024-07 release of the GraphQL Admin API, the availability of inventory is now checked during the billing attempt process.

Where product variants are configured to prevent overselling and one or more items in the contract are out of stock, then the billing attempt will fail with the new INSUFFICIENT_INVENTORY error code.

Learn more about subscription contracts and billing attempts on Shopify.dev.

We are introducing updates to our API that will enhance your experience and provide you with more flexibility:

1. Support for Query Arguments on Payouts GraphQL Field:

   • You can now utilize Shopify's API search syntax to filter and sort payouts using the sortKey and savedSearchId parameters. This functionality allows you to efficiently search and organize payouts based on specific criteria such as ledger_type, status, amount, currency, and issued_at.

2. Addition of Missing Attributes to ShopifyPaymentsBalanceTransaction GraphQL Object:

   • We have enriched the ShopifyPaymentsBalanceTransaction GraphQL object by introducing the following attributes:
     • source_id: Represents the ID of the resource that led to the transaction.
     • source_order_transaction_id: Indicates the ID of the Order Transaction that triggered the balance transaction. If the source_type is an adjustment, this value will be null.
     • adjustment_order_transactions: An array of associated order transactions that resulted in the balance transaction. If the source_type is not an adjustment, this array will be null. Each object in the array includes:
     • adjustment_reason: Specifies the reason for the adjustment associated with the transaction. If the source_type is not an adjustment, this value will be null.

As of GraphQL Admin API version 2024-07 you can query the following fields on the ShopifyPaymentsBalanceTransaction object: - description - amount - fee - source_type - type - associated_order - associated_payout - test

Learn more about ShopifyPaymentsBalanceTransaction on Shopify.dev.

As of API version 2024-07, you can use the webhookSubscriptionsCount field to return a count of webhook subscriptions. This field returns a Count object type with precision and count fields.

As of API version 2024-07 of the GraphQL Admin API, your app can subscribe to the customer_account_settings/update webhook topic.

This webhook is triggered when a merchant changes customer account settings.

For example, if a merchant chooses new customer account, requires login on checkout and shows login link on online store, the payload in the webhook will look like:

{
 url: 'https://shopify.com/1234567890/account',
 customer_accounts_version: 'new_customer_accounts',
 login_required_at_checkout: true,
 login_links_visible_on_storefront_and_checkout: true
}

If a merchant chooses classic customer account, does not require login on checkout and does not show login link on online store, the payload in the webhook will look like:

{
 url: null,
 customer_accounts_version: 'classic',
 login_required_at_checkout: false,
 login_links_visible_on_storefront_and_checkout: false
}

Learn more about these webhooks on Shopify.dev

As of version 2024-07, the HTTP Post request sent from Shopify to initiate a payment session on a Credit Card Payments App Extension contains a new Boolean moto field in the payment_method.data hash, to flag if the credit card information for a payment was entered by a merchant. Learn more about payment session creation on Shopify.dev.

As of 2024-07, you can use the validationResultSummary field on the mailingAddress type to query the validation status of an order's shipping address.

Possible values defined in MailingAddressValidationResult enumerated type with possible values of ERROR, WARNING, NO_ISSUES and null. A null value indicates that the address has not undergone validation.

Learn more about how Shopify validates customer addresses at help.shopify.com

As of 2024-07 StoreCreditAccount queries and mutations are available to merchants globally in the GraphQL Admin API. A new transactions connection has been added to the StoreCreditAccount, displaying the full transaction history of the account.

A customer who is authenticated with new customer accounts will be able to see and spend their store credit at checkout.

It's now possible to view the logged in customers StoreCreditAccount when using the GraphQL Customer Account API.

As of GraphQL Admin API version 2024-07, various fields on Product Variants that are duplicates of the linked Inventory Item will be removed from the Product Variant model, input types, and webhooks, as well as restrictions to

GraphQL Fields

In general the fields removed (and their replacement) are:

• fulfillmentService: The fulfillment service is now defined by where the item is stocked, and the fulfillment services that own those locations.
• harmonizedSystemCode: This is replaced by the harmonizedSystemCode field of the inventory item.
• inventoryManagement: This is replaced by the tracked field from the inventory item. Inventory management information is more clearly defined with both the tracked and fulfillmentService fields on the inventory item.
• requiresShipping: This is replaced by the requiresShipping field of the inventory item.
• sku: This field will continue to be returned on the Product Variant model, but is not directly editable. Rather the field will just proxy the sku field from the inventory item.
• weight and weightUnit: These fields are replaced by the weight type in InventoryItem.measurement.weight.

More specifically, these fields are kept or removed:

• From ProductVariantInput: fulfillmentServiceId, harmonizedSystemCode, inventoryManagement, requiresShipping, sku, weight, and weightUnit are all removed.
• From ProductVariantsBulkInput: fulfillmentServiceId, harmonizedSystemCode, requiresShipping, sku, weight, and weightUnit are all removed.
• From ProductVariantSetInput: harmonizedSystemCode, requiresShipping, weight, and weightUnit are all removed. sku is kept.
• From ProductVariant return type: fulfillmentService, harmonizedSystemCode, inventoryManagement, requiresShipping, weight, and weightUnit are all removed. sku is kept.

Metafields

As part of this work, you'll no longer be able to set the harmonized_system_code metafield under the global namespace for Product Variants. This was an alternative way of updating the harmonized_system_code of a variant, but since variants are no longer going to have the harmonized_system_code field, the metafield is being removed.

Webhooks

The Product Variant webhooks are also seeing some fields removed, namely:

• fulfillment_service
• inventory_management
• grams
• weight
• weight_unit
• requires_shipping

As of admin API 2024-07, we will have new mutations and queries: * mutation subscriptionBillingCycleBulkCharge * mutation subscriptionBillingCycleBulkSearch * query subscriptionBillingCycleBulkResults * mutation subscriptionBillingCycleCharge

Learn more about those on * Shopify.dev - Manage billing cycle contract - Create an order. * Shopify.dev - Manage billing cycles in bulk

As of API version 2024-07, the Metafield and MetaobjectField objects now have a jsonValue field returning the stored value as a JSON scalar. This is particularly helpful for metafield values that are stored as JSON strings to avoid having to parse client-side. This field is set for all metafield types and is also available in all Function APIs. It can be used in Function input queries to improve function performance and reduce the instructions needed to parse JSON metafield values, which are commonly used for function configuration.

As of GraphQL Admin API version 2024-07, you can query the field typOspPagesActive. This field returns the status of the Thank You Page (TYP) and Order Status Page (OSP) on a CheckoutProfile, providing insight as to whether or not these pages have adopted extensibility or not.

When true, both Thank You Page and Order Status Page are using extensibility, and will render the appropriate UI extensions, while also making use of pixels, and functions. When false, the pages still use additional scripts and other deprecated features.

Learn more about CheckoutProfiles on Shopify.dev.

As of the 2024-07 version of the Admin GraphQL API, the variants and productOptions fields in the ProductSetInput will become optional. The fields are codependent, meaning they must either both be present or both be absent.

Learn more about productSet on Shopify.dev.

As of version 2024-07 of the Admin GraphQL API we are introducing the following changes: * We’ve added active, supportsServiceDiscovery, and callbackUrl fields to the DeliveryCarrierService object. * We’ve added carrierServices to the query root to list and filter the carriers services of the shop. * We’ve added carrierServiceCreate to create a new DeliveryCarrierService. * We’ve added carrierServiceUpdate to update the properties of a DeliveryCarrierService. * We’ve added carrierServiceDelete to delete a DeliveryCarrierService.

As of version 2024-07 of the Admin GraphQL API, you can use the new trackingSupport field in FulfillmentService to check whether the fulfillment service implements the /fetch_tracking_numbers endpoint.

Learn more about FulfillmentService on Shopify.dev.

As of version 2024-07 of the Admin GraphQL API, you can use the new createdAt field in FulfillmentEvent to check the date and time when the fulfillment event was created.

Learn more about FulfillmentEvent on Shopify.dev.

As of version 2024-07 of the Admin GraphQL API, you can use the new fulfillmentsCount field in Order to count the number of fulfillments including the cancelled fulfillments that belong to an order.

Learn more about Fulfillment on Shopify.dev.

As of 2024-07 version in the admin GraphQL API, you can specify whether to include translations when calling the productDuplicateAsyncV2 mutation. When this optional argument is passed in as true, all translations that are saved on the product, its variants, and its metafields are copied over to the new product.

We're deprecating the TRANSPARENT value on the CheckoutBrandingBackground enum of the Admin GraphQL API checkoutBranding query and checkoutBrandingUpsert mutation. Use BASE or SUBDUED instead.

We will remove this value from the mutation input and the GraphQL API in the subsequent API version (2024-07). To prepare for the 2024-07 API version release, stop using the TRANSPARENT value.

As of the 2024-07 version of the Customer Account API, you will be able to use the metafieldsSet mutation to assign metafield values on Customer, Order, Company, and CompanyLocation resources.

As part of this change, the Customer Account API will need to be granted explicit read or read/write access to metafield definitions in order to have access. This represents a breaking change because as of this version, metafield definitions without access permissions will not be available to the Customer Account API.

The 2024-07 version of the Admin API will allow you to set access controls as part of the metafieldDefinitionCreate and metafieldDefinitionUpdate mutations.

These changes can be tested today on the unstable versions of the Customer Account and Admin APIs.

As of GraphQL Admin API version 2024-07, we're adding the DeliveryPromiseProvider object, which represents an entity (such as a third-party service) that can provide delivery estimates on behalf of a shop. Currently, this is available only to select approved delivery promise partners.

Each DeliveryPromiseProvider object is associated with a shop Location.

A DeliveryPromiseProvider object can be created or updated using the deliveryPromiseProviderUpsert mutation, and retrieved using the deliveryPromiseProvider query.

Learn more about the DeliveryPromiseProvider object, the deliveryPromiseProviderUpsert mutation, and the deliveryPromiseProvider query.

As of 2024-07, you can use the following metafields to save link related content: * link: A link consisting of an anchor text and URL. * list.link: A list of link metafields.

Learn more about metafields on Shopify.dev.

As of the 2024-07 version of the Admin GraphQL API, the id field in the ProductVariantSetInput will have validation to prevent duplicate values.

This enhancement ensures that there are no collisions when updating variants.

Learn more about productSet on Shopify.dev.

As of version 2024-07 in the GraphQL Admin API, the discountedPriceSet and discountedPrice fields of the object ShippingLine will include cart level discounts applied to an order, including the free shipping discount, when calculating the discounted price. Previously, you would have had to subtract the discountAllocations from discountedPriceSet or discountedPrice to get an accurate value, but doing so now will subtract the same discount twice.

Learn more about Shipping Lines on Shopify.dev.

As of version 2024-07 of the Admin API, you can use the checkoutBrandingUpsert mutation to configure styling and visibility of dividers.

With this change, the dividers below the header, above the footer, between the main and order summary columns, and between sections in the main column can now be customized with visibility, style and width controls.

You can learn more about these customizable dividers in the GraphQL Admin API docs: Global divider style, Footer divided property, Header divided property, Order Summary divider property, Main divider property, and Content divider property

As of the 2024-07 release of the admin GraphQL, you can access assigned fulfillment orders from QueryRoot.assignedFulfillmentOrders instead of the pre-existing Shop.assignedFulfillmentOrders connection.

This change will include the deprecation of the Shop.assignedFulfillmentOrders query in favour of the newly added QueryRoot.assignedFulfillmentOrders

This change aligns with direction of the admin API moving forward ensuring that domain primitives are available on QueryRoot and the Shop field is reserved for key information related to the shop in the scope of the request.

You can learn more about assigned fulfillment orders here.

As part of the 2024-07 release, delivery-related discounts into the Storefront API's Cart discountAllocations field and a new targetType field have been added to differentiate the type of discount. The merchandise and delivery discounts are reflected in the totalAmount of the Cart.

Learn more about the Cart object on Shopify.dev.

As of GraphQL Admin and Customer Account APIs version 2024-07, you can now set metafields using compare-and-swap (CAS) through the new compareDigest field for the metafieldsSet mutation.

Using CAS will add support to properly handle concurrency requests.

As of version 2024-07 of the GraphQL Storefront API, Cart supports one-time use delivery addresses with the new oneTimeUse property of the DeliveryAddressInput. Use this new property to pass an address that should not be saved to the account of the customer after checkout. A typical use case is when a store specializes in gifting scenarios.

API Reference - DeliveryAddressInput

As of 2024-07, when creating, updating or querying a webhook subscription you can now include a filter parameter. This parameter, which is specified using Shopify Search Syntax, allows you to specify conditions as to when webhooks should be emitted for a subscription.

Learn more about webhook filters on Shopify.dev.

As of 2024-07, the subTopic argument has been removed for creating webhook subscriptions. For creating subscriptions that previously required a subTopic the filter argument should be used instead.

Learn more about webhook filters on Shopify.dev.

We've added more data fields to Web pixels so that you can capture richer data and improve the performance of your integrations.

Standard API -> init -> shop object including: * Country code * myShopify url * Payment settings

Standard Events -> checkout object including: * Discount amounts * Email marketing consent * Final line item price * Line item properties * Line item selling plan * Localization * Payment method * Selected delivery options * SMS marketing consent

Shopify webhoks are first-class citizens with our APIs, and we now finally have a reference experience too! Now, all of Shopify's webhook topics are discoverable in a single-source-of-truth place. The reference docs include sample payloads, which topics are available for subscription based on the method you use, and key information like required access or approval scopes.

Webhooks are now managed by Shopify! Configure app-specific subscriptions as opposed to per shop. Using Shopify CLI v3.63.0 or later, add, modify and deploy app-specific subscriptions in your app configuration file (shopify.app.toml), then view the latest version in your Partners dashboard.

To get started, use the new tutorial for Shopify webhook subscriptions.

The token value in the JSON of the cart response now includes a key param as of 2024-06-21. This response is returned when the cart is manipulated or queried using Shopify's Ajax API for Cart.

Example Format: ** * Before: token:c1-7a2abe82733a34e84aa472d57fb5c3c1 * After: token:c1-7a2abe82733a34e84aa472d57fb5c3c1?key=824bdj25mhg1242bdb385**

*Action Required: * Ensure that your code is free from hard-coded assumptions (e.g. Using regex to identify a cart token) about the format and structure of the cart JSON response. If this value is stored as a key in an external database, ensure this change does not break the existing functionality. If storage of the cart token is required, we recommend using the complete value including the key param.

Build extensions on the pre-authenticated Order Status Page as a part of the Customer Account Extensibility Developer Preview to create a consistent experience for customers, regardless of their login or authentication state.

Customer account extensibility, currently available in developer preview, enables partners to add unique and powerful customizations by building extensions directly into new customer accounts.

Learn more about the pre-authenticated Order Status Page in our developer documentation.

As a part of the Customer Account Extensibility Developer Preview, you can now add, remove, preview, and reposition customer account UI extensions in new customer account pages, to better understand how merchants configure apps in the checkout and accounts editor.

Included in this update, you can also:

• Group extensions into collections: Extension collections guide merchants on which extensions work well together by creating collections that help merchants confidently enable your recommended customer experience.
• Set default placements: Default placements automatically add an extension to a specified UI block.

Customer account extensibility, currently available in developer preview, enables partners to add unique and powerful customizations by building extensions directly into new customer accounts.

Get started by reading our developer documentation.

Store and access customer information by writing data to metafields with the Customer Account API, and build experiences for merchants that enable logged-in customers to update information about themselves.

Custom customer data previously stored exclusively outside of Shopify can now be accessed and added directly to the customer record via using the Customer Account API. With the 2024-07 release of the Customer Account API, use the metafieldsSet mutation to assign metafield values on Customer, Order, Company, and CompanyLocation resources.

Learn more about writing data to metafields with the Customer Account API by reading our developer documentation.

As of Shopify CLI 3.63, log streaming and replay for Shopify Functions is available in beta.

Log streaming for Shopify Functions enables faster development, testing, and debugging of functions by bringing function execution logs to Shopify CLI. You can also replay function executions locally using input from these logs.

Learn more about enabling and using log streaming on Shopify.dev.

You can now contribute your own templates to Flow’s template library using the Shopify CLI. Templates show merchants how to automate something in their store and typically accelerate adoption of new tasks.

Once you have a workflow to share as a template, you can use the Shopify CLI to generate a new template app extension, configure all of its metadata including localizations, preview the extension, and deploy it. Once approved by the Flow team, it will appear in Flow’s template library.

View the Create a workflow template documentation to learn more about the process of creating and deploying template app extensions.

We've introduced the following changes to improve and update the App Design Guidelines:

• FullscreenBar usage within a max modal is now a "Do Not". The FullscreenBar section of the App Design Guidelines has been removed as it is no longer supported.
• Proper grammar is now included as a "Must Do".
• Using the App Bridge Contextual Save Bar API (where applicable) is now a "Must Do".
• Added a new section to the App Design Guidelines that includes specific requirements for subscription apps.

Managed pricing makes it easier to set up app pricing plans through your Partner Dashboard. Define recurring monthly/annual and free plans in your app listing page, then embed the URL in your app. Shopify handles creating and hosting your plan selection page, and automates most common billing tasks, such as recurring charges, free trials, proration, test charges, and price updates.

Managed pricing also allows you to easily issue app discounts and trial extensions through the Partner Dashboard. Merchants get an automated confirmation email when discounts and trial extensions are applied to their accounts.

Learn more about getting started with managed pricing.

Developers can now add admin print actions to their apps. These extensions let your apps create seamless workflows for printing documents - such as packing slips, invoices, and product information - direcly from the Order and Product pages in the Shopify admin.

Get started today by learning how to develop and deploy a print extension!

Shopify App Store Ads’ metrics now update in real-time. Partners will get immediate feedback when they refresh their ad report on their ads’ performance as auctions, impressions, clicks, and installs are happening live. To learn more about these metrics visit Shopify.dev.

As of version 2024-07 of the GraphQL Admin API, you can now read and modify Menus.

Structured app category details are now available for 30 more categories. You can fill out the fields from your app listing pages. This new information will help us match your apps to the right merchants more accurately, optimize ads bidding, and improve the overall discovery.

The 30 categories that now supports structured app category details are:

• Abandoned cart
• Ads
• Affiliate programs
• Analytics
• Badges and icons
• Banners
• Bulk editor
• Cart customization
• Chat
• Cookie consent
• Currency and translation
• Digital products
• Image editor
• Invoices and receipts
• Inventory sync
• Marketplaces
• Order tracking
• Payments
• Print on demand (POD)
• Product feeds
• Product variants
• Retail
• Search and filters
• Shipping
• Shipping rates
• SMS marketing
• Social proof
• Store data importer
• Upsell and cross-sell
• Workflow automation

For more information, please refer to our dev documentation.

Writing JSON for Liquid themes is already easy with intelligent code completion and inline documentation, but now it's also easier to refactor as we move objects in your schema tags and your settings_schema.json files with support for trailing commas and comments.

Note: Apps that parse JSON definitions from themes can still use pure JSON, but they should introduce support for reading (parsing) comments and trailing commas to handle eventual changes made directly on theme files.

Learn more about the JSON editing experience and JSON with comments at Shopify.dev - VS Code extension and Shopify.dev - Theme architecture. Happy coding!

Partners with apps that qualify for Built with Shopify status are now able to target their search ads on the Shopify App Store to specific merchant plans.

Learn more at Shopify.dev.

A new type called ProductOptionValue has been added to the new storefront API and is nested as a new field optionValues on the ProductOption type.

As of 2024-07, you can use the optionValues field to fetch the option values associated with an option. This field deprecates the existing values and provides richer option value information including swatches.

As of 2024-10, OrderDisplayFulfillmentStatus will now return REQUEST_DECLINED for an order that has had its fulfillment request rejected by a third-party Fulfillment Service. Previously, orders in this state would return an UNFULFILLED status.

As of 2024-07, you will receive a detailed error message when missing payment information for subscriptionDraftCommit mutation.

As of version 2024-07 of the GraphQL Admin API, draftOrderLineItemInput now accepts bundleComponents. Apps can view a bundle item's components on a draft using the bundleComponents field and can add a bundle item to a draft order by including this field in the draftOrderLineItemInput.

Additionally, the CartTransform function will automatically run on all draft orders.

Learn more about bundleComponents on shopify.dev.

In 2024-04 we released a new Taxonomy API for products. This included introducing a new TaxonomyCategory type and updating the product type to return a new category field.

As of 2024-07 the ProductInput type will also accept a category field that accepts the GID of a category.

We've also deprecated shop.allProductCategories in favor of shop.allProductCategoriesList

Breaking change: UI Extensions on version 2024-07 can use new API capabilities to integrate with split shipping capabilities.

Split shipping in checkout allows buyers to select different shipping options for items arriving in multiple shipments. In split shipping scenarios, Checkout will include UI changes to offer more transparency and options for buyers in the shipping section, while making the selection process easy with split shipping options (“Lowest price”, “Fastest” or “Custom”).

API updates

As of 2024-07, purchase.checkout.shipping-option-list.render-before and purchase.checkout.shipping-option-list.render-after will receive a new DeliveryGroupList target representing the list of delivery groups for One Time Purchase or Subscription delivery groups. These targets continue to be duplicated for the possible types of delivery groups. We’re also introducing deliverySelectionGroups which represents the list of predefined choices for the “Lowest price”, “Fastest” or “Custom” shipping options that are presented to the buyer. You can view these changes on the ShippingOptionListApi.

Note that useDeliveryGroupTarget() is deprecated in favor of useDeliveryGroupListTarget(). Extensions on 2024-01 and 2024-04 are compatible with split shipping but will only receive the first delivery group of each type (One Time Purchase or Subscription).

UI extension target updates

purchase.checkout.shipping-option-item.render-after and purchase.checkout.shipping-option-item.details.render targets can now be rendered in different contexts: inline as part of the split shipping options, or in an overlay for the “More shipping options” modal.

As a result:

• ShippingOptionItemApi has been updated to include a renderMode indicating in which context the target is rendered.
• Only purchase.checkout.shipping-option-item.render-after can be rendered in both contexts.
• purchase.checkout.shipping-option-item.details.render will also be duplicated for the selected shipping option of each delivery group.

If your extension is capturing buyer inputs at Checkout (for example using an app metafield), you will need to update your logic to account that this information should be scoped to a specific delivery group, instead of the entire order.

You can learn more about the new placement of targets and see examples.

These changes can be previewed today on the unstable api version and will be available on the stable branch with version 2024-07.

Learn more about these api changes on shopify.dev

We have refreshed our app taxonomy for better app discoverability. Designed to streamline categories and reduce complexity, this update will help merchants more easily find the best apps for their needs.

We encourage you to:

• Review the new taxonomy: See new categories and how it affects your app’s placement. All apps will continue to be discoverable and we’ll do our best to choose a suitable alternative for those impacted.
• Update your app’s category: Select the most suitable category for your app from your partner dashboard. All apps can make a one-time category change. Any subsequent changes will require an appeal.
• Impact on ads: Your category ads campaigns may be impacted if they are in these categories. You may need to relaunch your campaign.

As of 2024-07, you can use the RefundLineItem.id to return the id of specified RefundLineItem object.

Learn more about working with RefundLineItem on Shopify.dev.

The CartLinesUpdate mutation behavior has been updated to preserve existing line properties when the attributes parameter is either omitted or explicitly set to null. Previously, omitting the attributes parameter would reset the line properties. Passing an empty hash { } to reset line properties is an existing capability and remains unchanged.

As of 2023-04, the default sort key for discountNodes, codeDiscountNodes, and automaticDiscountNodes queries has changed to ID. Previously the default sort key was CREATED_AT. This change improves performance.

As of 2024-07, we're deprecating buyerIdentityInput.walletPreferences. Use buyerIdentityInput.preferences.wallet instead.

Learn more about these changes on Shopify.dev.

Discount Functions are now compatible with B2B companies that are required to submit orders as drafts for review.

Previously, Discount Functions weren’t applicable when B2B buyers submitted orders as drafts for review. This restriction has now been lifted, and buyers will have discounts applied at checkout.

It is now possible for merchants to share all function run details for an app within the last 24 hours with the app developer. This will share function run details for every function on the app, including both success and failure runs.

To learn how merchants can perform this action, see the relevant dev docs.

We are adding a limit to the number of fulfillment constraint rules that can be applied to a shop - currently, this limit is 10. As a result, we are also adding a new error code to the API.

As of API version 2023-07, the error code maximum_fulfillment_constraint_rules_reached will be added to the FulfillmentConstraintRuleCreate mutation. This error code is returned when you add more than the maximum number of rules to a shop.

Hydrogen v2024.4.3 is out today. The June 2024 Hydrogen release contains several new features and bug fixes, including:

• A new useOptimisticCart hook
• A new <RichText /> component to render rich_text_field metafields
• Stable analytics
• An upgrade to Remix 2.9.2

Check out our full Hydrogen June 2024 release blog post for more details. And please drop your comments, feedback, and suggestions in GitHub Discussions!

With POS app version 9.10 we now officially support discounts created by Discount Functions.

Here are some of the things to be aware of with regards to this announcement:

What are Shopify Functions?

Shopify Functions give you the flexibility to extend or replace native Shopify server-side business logic, to meet your unique business needs. For Discount Functions, that means being able to create discounts that cover more advanced use cases than what’s offered natively in the Shopify Admin discounting functionality.

Some use cases: - Trigger discounts based on attributes not available to be used natively, such as custom metafields or the customer’s lifetime value - Create more advanced criteria for discounts to be eligible, such as “Buy A, B and (C or D), get E for free” - Link discounts to other functionalities (loyalty, gift registry, membership)

What’s the lifecycle of a Shopify Function?

• App developers create and deploy apps that contain functions
• Merchants install the app on their Shopify store and configure the function. An API call is made with the function configuration
• Customers interact with a Shopify store, for example by visiting a retail location and buying a number of products, Shopify executes the function as the cart is updated and the merchants’ staff checks out the customer

Important information:

What exactly is changing now?

Over the last couple of months we launched new features on Shopify POS such as the ability to combine discounts as well as the support for BXGY discount codes. With these releases, we increased the support for more advanced Discount Function scenarios.

With v9.10 we are releasing some improvements that further bring the use of Discount Functions into the POS ecosystem, including automatic discounts, the ability to create smart grid tiles for discount codes that trigger a Discount Function, as well as improved error handling for discount codes.

Limitations:

There are currently a few limitations that are important to be aware of: - Discount Functions are automatically available to any sales channel, meaning that if a Discount Function was set up to automatically apply based on a certain input, it would be applied to orders that qualify in both Online Store as well as POS. The same counts for Discount Functions that are applied through discount code - Stores on any plan can use public apps that are distributed through the Shopify App Store and contain functions. Only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs

For app developers:

• We have extensive pre-existing docs on Shopify Functions - General and API - available on our .dev docs website. A tutorial can be found here

In Shopify admin:

• Any previously created Discount Functions are automatically available to be leveraged on POS
• For staff members to be able to leverage a Discount Function, a discount will have to be created with an app that deploys that function
• To make a discount created by Discount Functions available for smart grid tile linking, it has to be “published” to the POS, which can be done via bulk editor in the Admin > Discounts list overview

In store flows:

• For the staff in store, nothing will change. Discounts created through native functionality or discount functions will behave the same on POS
• Discount Functions can be configured to apply automatically, or can be triggered by entering a discount code

Technical:

• The following API’s are relevant to this functionality:
  • Shopify Functions
  • Order Discount Function API
  • Product Discount Function API
  • Shipping Discount Function API
• There are no functional changes to APIs

Reporting: - Discounts created through Discount Functions are of the same type as native discount (automatic / code, product/order/shipping). These discounts are reported on regardless of whether they were created natively or through discount functions

As of API version 2024-07, you can use the url_parameter_value as a tracking parameter in the MarketingActivityCreate and MarketingActivityUpdate mutations. This feature is currently available on a limited basis to some partners only. UTMs should continue to be used for most partners' tracking parameters.

Additionally, MarketingActivityUserError will be the required type on the user_errors field for the MarketingEngagementCreate mutation. This will match the user_error types of the other mutations that belong to the Marketing Activity and Engagements API.

We've given listing pages a refreshing uplift to improve overall density and readability.

A sticky sidebar keeps important highlights and the Install app CTA always in merchants' view. We continue to roll out more support for structured features for more app categories, so we've adjusted this section to accommodate growth.

This listing update is entirely a front-end refresh to keep the browsing experience high-quality for our merchants. No listing functionality will be impacted.

As of version 2024-07 of the Admin GraphQL API, you can use the new ordersCount field to count the orders for a given shop.

Learn more about ordersCount on Shopify.dev.

As of Admin API 2024-07, Order object will expose the following new fields:

• staffMember
• sourceName

Learn more about Order GraphQL object on Shopify.dev

As of GraphQL Admin API 2024-07 version, you can make use of a new mutation to delete an order.

Learn more about orderDelete on Shopify.dev.

As of Admin GraphQL API version 2024-10, we're deprecating the ability to set the available quantity on the InventoryActivate GraphQL mutation for already active states. Moving forward, use the InventorySetQuantities GraphQL mutation instead. This change will take into full effect starting on the 2024-10 version of the Admin GraphQL API.

As of Storefront API version 2024-07, you will get a NOTE_TOO_LONG user error in cart mutations in case the note exceeds the maximum number of 5000 characters.

As of 2024-07, the admin and storefront fields of MetafieldAccessInput and MetafieldAccessUpdateInput will begin using dedicated input enum types - MetafieldAdminAccessInput and MetafieldStorefrontAccessInput.

Learn more about access controls for metafields on Shopify.dev.

Customize the address autocomplete provider in Shopify Checkout with the Address Autocomplete API. The Address Autocomplete API unlocks the ability for developers to replace the default provider of address suggestions in Shopify Checkout. This allows merchants who have upgraded to Checkout Extensibility to leverage a growing ecosystem of third-party apps that augment the address autocomplete experience.

API Reference

• purchase-address-autocomplete-suggest
• purchase-address-autocomplete-format-suggestion

Pre-select your app’s capabilities early in the submission process to get a simpler, personalized list of requirements. If your app review gets paused due to a blocking error, a clear summary of issues and a straightforward resubmission process will help you (and your app review) quickly get back on track.

We are rolling this out to English speaking partners first this week. For more information on app review, see our dev docs.

Apps can now trigger Shopify's marketing automations that use the Customer subscribed to email marketing trigger (welcome new subscriber, and welcome series) by integrating with the Customers API.

When developers provide consentUpdatedAt upon updating the email marketing consent for a customer, the trigger and associated marketing workflow will fire as long as consentUpdatedAt is within the last 24 hours.

This change allows standalone lead capture apps to connect seamlessly with the rest of Shopify’s marketing automation tools. Apps that also offer automations should make sure merchants are aware they should choose to automate welcome emails in one place, not both, to avoid duplicate messages.

Tax lines created as a result of tax exemptions on orders (typically have price=0) will now be returned in API responses. This includes cases when the order, customer or product variant have been marked to not collect taxes (i.e. when the "Charge taxes" or "Collect Tax" checkbox is set to false).

This change is being released to stores progressively, with a plan to fully release it by May 23, 2024. The change will affect orders on stores that have the feature and have the appropriate tax registrations set up for collecting taxes on those orders

As of 2024-04, you can use the preferences object in the Cart API to prefill a checkout session.

These changes help merchants streamline their checkout process for their customers by prefilling information such as the preferred delivery method and pickup location. This change is additive to the 2024-04 version.

Learn more about these new fields in the cartCreate reference page and the CartBuyerIdentity reference page

For more information, an updated tutorial is also available.

As of 2024-07, the Payment Customization API has two new features that give you better control over accelerated checkout methods: 1. Improved naming: the function input graph now has more descriptive and specific names for accelerated checkout methods. 2. Placement control: Shopify Plus merchants will also be able to pass an optional placements argument in the hide operation, allowing them to explicitly hide accelerated checkout methods from the first or last step of checkout independently.

To learn more about payment customization functions, please refer to the documentation.

UI extensions and web pixels for public or custom apps on the Thank you and Order status pages are now available to merchants on Basic, Shopify and Advanced plans. In tandem, merchants will also have access to the new checkout and accounts editor, an all-in-one place for making customizations.

Additional scripts and apps with script tags on the Thank you and Order status pages will be turned off with one year notice. These must be replaced with a compatible app from the Shopify App Store or rebuilt with UI extensions and web pixels.

As previously stated, customizations for the Thank you and Order status pages achieved using checkout.liquid, script tags, and additional scripts will be turned off for Plus merchants on August 28, 2025.

More information can be found in our developer documentation.

Shopify Plus merchants using Shopify Payments are able to partially capture authorizations more than once. However, sometimes you know that the capture you're about to perform will be the last one. To reflect this, the orderCapture mutation has been updated in the 2024-07 version to support a new finalCapture parameter.

When you know you're capturing an authorization for the last time, setting the finalCapture parameter to true will release any uncaptured funds back to your customer. Doing so is likely to increase customer satisfaction and decrease the risk of chargebacks.

See also:

• Shopify Payments now supports multiple payment captures for the same order
• Shopify Payments now supports multiple payment captures for the same order in Australia and Romania

For merchants not on the Shopify Plus plan, the finalCapture parameter will have no effect: these authorizations can only be captured once, and uncaptured funds are always returned immediately to the customer.

At the time of writing, the finalCapture parameter only applies to transactions made through Shopify Payments. When capturing authorizations processed through other gateways, finalCapture must either be omitted, or set to null.

When handling requests with exceptionally large quantities (exceeding 1,000,000), the update endpoint of the Carts API previously capped the value to 1,000,000 and returned a 200/OK status without notifying the user.

We have now modified this behavior. While the update endpoint will continue to limit the quantity to 1,000,000, it will also issue a 422/Unprocessable Entity status alerting the API users to the adjustment.

The endpoint will not perform any additional quantity checks against inventory levels; this aspect remains consistent with previous functionality.

It is now possible for apps to view the access field of metafield definitions they have access to but do not own. An AuthorizationError error was previously returned when accessing the field for definitions the app didn't have permissions to manage. Note that accessing the access.grants field still requires permissions to manage the definition and an error will be returned if accessing the field with insufficient permissions.

As of 2024-07, the admin and storefront fields of MetafieldAccess will also start returning values in more cases instead of null. Metafields that do not have associated access grants will return PUBLIC_READ_WRITE for admin access and LEGACY_LIQUID_ONLY for storefront. In addition, definitions that were created with a storefront access of NONE will start returning NONE instead of null. Finally, it will also now be possible to set PUBLIC_READ_WRITE as the admin access control.

Learn more about access controls for metafields on Shopify.dev.

Hydrogen v2024.4.2 is out today. The May 2024 Hydrogen release contains several new features and bug fixes including:

• Redeploys on Oxygen
• B2B Support
• Improved support for third party requests in the request profiler
• Improved HMR stability
• Node 21 compatibility
• Content security policy improvements
• Analytics improvements
• h2 upgrade command detects outdated devDependencies
• Codegen schema resolution fix
• cli-kit improvements

Check out our full Hydrogen May 2024 release blog post for more details. And please drop your comments, feedback, and suggestions in GitHub Discussions!

As of API version 2024-07, we've added the RESERVED_NAMESPACE_ORPHANED_METAFIELDS error code to the metafieldDefinitionDelete mutation. This error code is returned if you attempt to delete a definition in a reserved namespace without setting deleteAllAssociatedMetafields to true.

The cart cookie value for the Online Store now includes a key param. Not including the key param will result in the removal of buyer details and your updates will be applied to a newly generated cart. This behavior is applied retroactively to all themes.

This change is rolling out now, and enforcement will go into effect after a grace period of 1 week.

Example Format

• Before: value=c1-7a2abe82733a34e84aa472d57fb5c3c1
• After: value=c1-7a2abe82733a34e84aa472d57fb5c3c1?key=824bdj25mhg1242bdb385

Action Required

Provide the complete cart cookie value which includes the key param as well as the cart token.

Ensure that theme code is free from hard-coded assumptions (ex. Using regex to identify a cart token) on the format and structure of the cart cookie. This is especially critical if the cart cookie is manually constructed. If your theme utilizes the value set by default without modification, no action is needed.

The Storefront API Cart ID now includes a key param that must be included for any mutation or query operations where the Cart ID is passed. Updating a cart without including the key param will result in the removal of buyer details and your updates will be applied to a newly generated cart. This behavior is applied retroactively to all versions of the Storefront API.

This change is rolling out now, and enforcement will go into effect after a grace period of 1 week.

Example Format: ** * Before: gid://shopify/Cart/c1-7a2abe82733a34e84aa472d57fb5c3c1 * After: gid://shopify/Cart/c1-7a2abe82733a34e84aa472d57fb5c3c1?key=824bdj25mhg1242bdb385**

Action Required: Provide the complete cart ID which includes the cart token as well as the key param. This value is returned from the graphQL API response when the cart is created.

Ensure that any app and theme code is free from hard-coded assumptions (ex. Using regex to identify a cart token) on the format and structure of the cart token. This is especially critical if the Cart ID is manually constructed. *If your app utilizes Cart.Id without modification, no action is needed. *

You can now configure the customer privacy permissions and data sale settings for app pixels using the Web Pixel API. This will provide more insights by collecting events whenever the proper permissions are given by customers.

Learn more about Web Pixels on Shopify.dev.

You can now create visual filters with an image presentation. This allows developers and merchants to specify when filters are best displayed as detailed images instead of color and pattern swatches.

In the Liqudi API, we've added filter_value.image intended for better display support for icons, logos, and other detailed imagery. The filter_value.swatch is intended for color and pattern swatches.

Merchants must use Shopify's Search & Discovery app to set visual filters for their store.

As of Admin API and 2024-07 version, we're sunsetting ShopifyQL API. Use the Admin GraphQL APIs instead for extracting data for your use-cases.

For example, the Orders API, and the Web Pixels API should be useful starting points.

Now, theme developers can utilize schema translation files to make default values in theme sections translatable. This ensures that themes are equipped to support multiple languages right from the onboarding state and when integrating new sections. For detailed guidance on how to reference schema translations, please refer to the developer documentation.

As of version 2024-07, 3D Models and External Videos will be included in the GraphQL Admin Files Query.

As of version 2024-07 of the webhooks API, the includeFields that are specified on a webhook subscription will be available for all webhook topics.

As of version 2024-07 of the GraphQL Admin API, you can use the Metafield and MetafieldDefinition connections in the OnlineStoreArticle, OnlineStoreBlog, and OnlineStorePage objects.

Previously, you could only do this using the REST API.

As of GraphQL Admin API version 2024-07 the location field on the Order object has been removed. Use the retailLocation field instead.

Learn more about the Order object on Shopify.dev.

The GraphQL Admin API's DiscountEffectInput input object now includes an amount field. This change is backported to version 2024-01.

As of GraphQL Admin API version 2024-07, you can use the new retailLocation field on the Order object to query the physical location where a retail order is created or completed.

Learn more about the Order object on Shopify.dev.

Effective May 15, 2024, a maximum value of $2,000USD (or equivalent in global currencies) has been added to gift card issuance. All versions of the Gift Card API will respond with an error for issued gift cards that exceed $2,000USD (or equivalent in global currencies) after this date. The purchase limit for gift card products will be $10,000USD (or equivalent in global currency).

To help you and Shopify merchants stay within this limit, we’ve introduced a new Gift Card Limits query that returns the maximum value in any given currency.

This change will help keep Shopify merchants compliant with laws that apply to gift cards and help ensure they do not inadvertently violate them. The new maximum value will not affect gift cards issued before May 15, 2024.

Visit our Help Center for more information.

We are currently testing a feature that can halve load times for embedded Shopify apps using App Bridge via script tag and have found cases where apps break when they rely on an undocumented name="app-iframe" property to access their iframe

If your app uses the name="app-iframe" property to find its embedded app iframe, please either upgrade to App Bridge React v4 or reference the snippet below (gist here for reference) to avoid your app breaking in mid May when we begin rolling out these performance enhancements

The performance enhancement works by keeping multiple app iframes in the DOM at any given time. The name=”app-iframe” prop will no longer be unique

const APP_ID = ''; // accessible via window.shopify.config.apiKey


interface FrameList extends Window {
   [index: number]: Window;
}


function findAppFrameSafely(frameName: string) {
   if (window.parent) {
       const frames = window.parent.frames as FrameList;
       for (let i = 0; i < frames.length; i++) {
           const frame = frames[i];
           try {
               // referencing the name prop of a cross-origin frame will throw when there are multiple frames with the same name
               if (frame.name === frameName) {
                   return frame;
               }
           } catch (_) {
               // noOp
           }
       }
   }
}


const legacyFrameName_doNotUse = 'app-iframe';
const futureProofFrameName = `frame:${APP_ID}/main`;


const appFrame = findAppFrameSafely(legacyFrameName_doNotUse) || findAppFrameSafely(futureProofFrameName);


// continue doing whatever you were doing with the app's main frame
appFrame?.postMessage({}, window.location.origin);

• Where APP_ID is your app’s apiKey, either provided during config or accessible on window.shopify.config.apiKey
• Your app’s iframes are same-origin while other apps’ iframes will be cross origin. The try / catch finds only same-origin frames, in this case, your app’s iframe
• To be future proof, also use the unique name=”frame:${APP_ID}/main”. At the close of this project, app iframe names will be changed from the static name=”app-iframe” to a unique identifier pivoting on APP_ID. Please accommodate this new pattern now so your app doesn’t break when we update names!

As of Shopify CLI 3.59, commands have been unified under a single npm package and our recommended installation method is as a global npm package. This provides developers with a single installation and upgrade point for all development with Shopify CLI.

Dependencies for Shopify CLI are now bundled into the package as well, reducing installation time and potential conflicts with developer dependencies.

Existing use of Shopify CLI as a local dependency in app and Hydrogen projects is still supported.

Learn more about installation in the new centralized Shopify CLI documentation and learn about migrating your app to use a global installation.

Up to this point, you can send Inventory Item data in two places: through Product Variant mutations or on the InventoryItemUpdate mutation. Each of these places has a different input object type with very similar fields, with some keys showing up in one instead of the other.

As of Admin GraphQL API version 2024-07, these two input types are being unified. InventoryItemInput will now be the input object type on inventoryItemUpdate instead of InventoryItemUpdateInput.

At the same time the following fields were added on InventoryItemInput:

• sku
• countryHarmonizedSystemCodes
• countryCodeOfOrigin
• provinceCodeOfOrigin

Hydrogen v2024.4.0 is out today. The April 2024 Hydrogen release contains several new features:

• Built-in Shopify analytics with an improved developer experience and support for third-party services
• Vite support is now stable, providing hot-module reloading that’s up to 10 times faster
• Improved tooling for SEO
• env push command to bulk upload environment variables is now stable
• Customer Account API client to simplify authentication.
• SSL tunneling functionality in the CLI.

In addition to these new features, Hydrogen 2024.4.0 includes a range of updates, performance upgrades, and bug fixes.

Check out our full Hydrogen April 2024 release blog post for more details. And please drop your comments, feedback, and suggestions in GitHub Discussions!

As of version 2024-07 of the GraphQL Storefront API, Cart supports adding and querying for Gift Cards.

Updating Gift Cards can be achieved in two ways: - When creating a cart - adding the CartInput giftCardCodes property. - After a cart is created - performing the cartUpdateGiftCardCodes mutation.

You can also query the cart for applied Gift Cards using the appliedGiftCards property.

As of version 2024-07 of the GraphQL Admin API, DraftOrderInput now accepts discountCodes and acceptAutomaticDiscounts. These optional input fields will allow you to apply discount codes to a draft order and decide whether or not to accept automatic discounts during calculation.

Additionally, a new type field named DraftOrderPlatformDiscount has been added that describes details about how the platfom discount has been allocated across the draft order line items, the discount type, its name, and more.

Learn more about DraftOrderPlatformDiscount on Shopify.dev

We have released a feature for Plus merchants who

1. Use products to represent additional fees or charges in checkout
2. Are currently using checkout.liquid to customize the order summary
3. Need a solution to continue doing so with checkout extensibility

Log into the Help Centre to connect with Plus Support who can assist with requesting access for eligible Plus Merchants

In version 2024-04 of the GraphQL Admin API, we exposed the cash tracking sessions that are created by Shopify POS. As of version 2024-07, you can use the API to query the cash transactions that are associated with each cash tracking session. The new cashTransactions connection returns all of the cash order transactions that affected the amount in the cash drawer during a cash tracking session.

To learn more, see CashTrackingSession (cashTransactions) in the GraphQL Admin API reference.

CartDiscountCode#code has been corrected to be case insensitive. For example, providing the input ["DISCOUNT", "dIsCoUnT", "discount"] on cartCreate or cartDiscountCodeUpdate will return a cart payload with one CartDiscountCode with the code value set to DISCOUNT.

You can now seamlessly integrate your app using admin action extensions at many more locations in the Shopify admin. These include draft orders pages, abandoned checkouts pages, and variant pages. You can find the full list of targets in the admin extension targets API reference.

Learn how to create your first admin action extension on Shopify.dev.

As of version 2024-04 the Storefront API field Cart.cartCost.checkoutChargeAmount will now return an estimated amount before taxes and discounts. In previous versions Cart.cartCost.checkoutChargeAmount was incorrectly returning the discounted cost.

We've added preloading of the Validation record and its metafields so that you can access them without the need of a fetch call. The Validation API will be gated by a new read_validations access scope in the near future, so you need to migrate to this new format for your extension to continue to work or the fetch call will start failing.

Learn more about Cart and Checkout Validation configuration on Shopify.dev.

As of GraphQL Admin API version 2024-04, you can use the new sort options in fulfillmentOrders query.

• createdAt: The date that the fulfillment order was created.
• fulfillBy: The date by which the fulfillment order should be fulfilled by the merchant.

As of today, the read_validations access scope will be required for the validation and validations queries. The write_validations access scope is required if you're using the validationCreate, validationUpdate or validationDelete mutations.

If you're building an extension for Cart and Checkout Validation configuration check our updated tutorial on Shopify.dev to see how to update it so that you don't need the new access scope.

As of 2024-04, fields that returned a count of resources will be removed and replaced with new count fields that have consistent API design and improved features.

API design and naming

Count fields are now standalone fields with a common naming pattern and their own arguments instead of being a field under a connection type.

Before:

query {
  products(first: 0) {
    totalCount
  }
}

After:

query {
  productsCount {
    count
  }
}

In the before example, the products connection field was overloaded with multiple behaviors (count and pagination) which caused confusion as to how, and if, arguments affected the resulting count.

With the new count fields, there's one clear behavior and it simplifies how field arguments affect the count.

Return type

Instead of varying Int or UnsignedInt64 return type, all count fields now return a Count object type with precision and count fields.

Precision

The new precision field indicates if a server limit was reached such that we returned early, reporting that there were "at least" n records.

For example, counting the number of products has a server limit of 10,000. If there were 42 products, the count object would look like { count: 42, precision: "EXACT" }. If there were 10,042 products, the count object would look like { count: 10000, precision: "AT_LEAST" }

Filtering

Some count fields will now accept filter arguments matching that of a neighboring connection, such as products and productsCount.

Migration

• CatalogConnection.totalCount --> CompanyLocation.catalogsCount, Market.catalogsCount, QueryRoot.catalogsCount
• Collection.availablePublicationCount --> Collection.availablePublicationsCount
• Collection.productsCount --> Collection.productsCount
• Collection.publicationCount --> Collection.resourcePublicationsCount
• Company.contactCount --> Company.contactsCount
• Company.locationCount --> Company.locationsCount
• Company.orderCount --> Company.ordersCount
• CompanyLocation.orderCount --> CompanyLocation.ordersCount
• CompanyLocationCatalog.companyLocationsCount --> CompanyLocationCatalog.companyLocationsCount
• CustomerJourneySummary.momentsCount --> CustomerJourneySummary.momentsCount
• DeliveryLocationGroup.locationsCount --> DeliveryLocationGroup.locationsCount
• DeliveryProfile.productVariantsCount --> DeliveryProfile.productVariantsCount
• DeliveryProfile.productVariantsCountV2 --> DeliveryProfile.productVariantsCount
• DiscountCodeApp.codeCount --> DiscountCodeApp.codesCount
• DiscountCodeBasic.codeCount --> DiscountCodeBasic.codesCount
• DiscountCodeBxgy.codeCount --> DiscountCodeBxgy.codesCount
• DiscountCodeFreeShipping.codeCount --> DiscountCodeFreeShipping.codesCount
• FulfillmentOrderLocationForMove.availableLineItemsCount --> FulfillmentOrderLocationForMove.availableLineItemsCount
• FulfillmentOrderLocationForMove.unavailableLineItemsCount --> FulfillmentOrderLocationForMove.unavailableLineItemsCount
• InventoryItem.locationsCount --> InventoryItem.locationsCount
• PriceRule.discountCodesCount --> PriceRule.discountCodesCount
• Product.availablePublicationCount --> Product.availablePublicationsCount
• Product.mediaCount --> Product.mediaCount
• Product.publicationCount --> Product.resourcePublicationsCount
• Product.sellingPlanGroupCount --> Product.sellingPlanGroupsCount
• Product.totalVariants --> Product.variantsCount
• ProductBundleComponent.componentVariantsCount --> ProductBundleComponent.componentVariantsCount
• ProductBundleComponent.nonComponentVariantsCount --> ProductBundleComponent.nonComponentVariantsCount
• ProductComponentType.componentVariantsCount --> ProductComponentType.componentVariantsCount
• ProductComponentType.nonComponentVariantsCount --> ProductComponentType.nonComponentVariantsCount
• ProductConnection.totalCount --> Channel.productsCount, Collection.productsCount, QueryRoot.productsCount
• ProductVariant.sellingPlanGroupCount --> ProductVariant.sellingPlanGroupsCount
• Publishable.availablePublicationCount --> Publishable.availablePublicationsCount
• Publishable.publicationCount --> Publishable.resourcePublicationsCount
• QueryRoot.channelCount --> QueryRoot.publicationsCount
• QueryRoot.companyCount --> QueryRoot.companiesCount
• QueryRoot.discountCodeCount --> QueryRoot.discountCodesCount
• QueryRoot.giftCardsCount --> QueryRoot.giftCardsCount
• QueryRoot.publicationCount --> QueryRoot.publicationsCount
• QueryRoot.segmentCount --> QueryRoot.segmentsCount
• SellingPlanGroup.productCount --> SellingPlanGroup.productsCount
• SellingPlanGroup.productVariantCount --> SellingPlanGroup.productVariantsCount
• Shop.limitedPendingOrderCount --> QueryRoot.pendingOrdersCount
• Shop.pendingOrdersCount --> QueryRoot.pendingOrdersCount
• SubscriptionBillingCycleEditedContract.lineCount --> SubscriptionBillingCycleEditedContract.linesCount
• SubscriptionContract.lineCount --> SubscriptionContract.linesCount
• SubscriptionContractBase.lineCount --> SubscriptionContractBase.linesCount

As of 2024-04, you now have read access to metafields on Company and CompanyLocation resources via the Customer Account API.

Learn more about the Metafield object on the GraphQL Customer Account API at Shopify.dev.

As of version 2024-04 of the Admin GraphQL API, you can use the productOptionsCreate, productCreate, and productOptionUpdate mutations to create metafield-linked product options.

Metafield-linked product options are only available in Shopify taxonomy early access.

Learn more about metafield-linked product options.

As of 2024-04, new GraphQL product APIs are now available in stable release.

These new APIs increase per-product variant support from our historical max of 100 to a new limit of 2000.

In addition to higher variant support, you can use the product option mutations to manage options and option values on your products. You can also query for your product's productOptions and your product variants' optionValues.

Learn more about the new product and option value GraphQL APIs on Shopify.dev.

Also included in this stable release, you can use the productSet mutation to set the entire state of a product from an external data source into Shopify, in addition to the existing mutations for adding/deleting/updating individual variants.

Learn more about the new productSet GraphQL API on Shopify.dev.

See our guide to sync product data from an external source for more information.

With the 2024-04 API release, we will also be deprecating management of both variants and options via the GraphQL ProductInput object and the /products and /variants REST API endpoints. Learn more here.

With the 2024-04 API release, along with the introduction of the new GraphQL product APIs, we are removing management of both the variants and options via the GraphQL ProductInput object and have marked as deprecated the /products and `/variants' REST API endpoints.

Below you can find migration information for public and custom apps built on existing GraphQL and REST product APIs.

Public Apps

All public apps built on existing GraphQL product APIs or REST product APIs must migrate to the new GraphQL product APIs by Feb 1st, 2025.

Custom Apps:

Custom apps built using the existing GraphQL product APIs must migrate to the new GraphQL product APIs by April 1st, 2025.

Custom apps built on REST will also need to migrate if they end up needing to support more than 100 variants.

Custom apps built on REST that do not need to support more than 100 variants can continue to use the deprecated REST product APIs, however it is important to note:

-Developers should expect that the GraphQL API will be the only supported API over the long term and will be made aware of these timelines as they become available.

-The deprecated REST product APIs are in maintenance mode; all new features and support will be built only for the new GraphQL product APIs.

-Any merchant using custom apps built with these deprecated APIs will not be able to increase their variant limit past 100.

As of 2024-04, you can use priceWithCurrency to provide the price of the shipping rate along with the currency, whereas price uses the shop currency. If priceWithCurrency is provided, price will be ignored.

Learn more about priceWithCurrency on Shopify.dev.

As of 2024-04, you can set LineItem attributes on Bundle items using CartTransform Merge and Expand operations.

You can set custom attributes to either the Bundle item or its components using the new field.

Learn more about Bundles on Shopify.dev.

As of Storefront API version 2024-04, you can use the @inContext directive to query product and productVariant fulfillable inventory for specified market country. The Fulfillable Inventory feature must be enabled.

query Contextualized @inContext(country:CA){
  product(id:"gid://shopify/Product/1" )
  {
        availableForSale
        totalInventory
        variants(first:1)
        {
          edges
          {
            node
            {
              id
              availableForSale
              quantityAvailable
              currentlyNotInStock

            }
          }
        }
      }
}

Learn more about Fulfillable Inventory on Shopify help docs.

As of 2024-04 developers can now sort and search Fulfillment Orders in GraphQL queries by the UPDATED_AT field.

This will help app developers and fulfillment services to prioritize their work on fulfillment orders and reduce the query cost when sorting and searching through other filters.

Learn more about sort and search parameters for fulfillment orders on Shopify.dev

As of API version 2024-04 the Checkout API’s will be marked as deprecated. This deprecation will impact both the Admin REST API (excluding Abandoned Checkout) and Storefront GraphQL API endpoints. To maintain continuity and unlock new capabilities, apps will need to migrate to either the Storefront Cart API, and or Checkout Sheet Kit for mobile apps.

Deprecation Schedule:

April 1, 2024 (Version: 2024-04) All affected fields within the Checkout APIs will be marked as deprecated. This is the final stable version where the Checkout APIs will remain available. The fields will also be removed from unstable and the 2024-07 Release Candidate versions onwards. We strongly recommend you to start migrating to the new API when possible to avoid any disruptions.

April 1, 2025 (Version: 2025-04) The 2024-04 API version will reach its end of life. As a result, Checkout mutations will no longer be available on any version.

Recognizing the need for a high throughput cart, Shopify introduced the Storefront Cart API in 2021 as the successor to the Checkout API, and we have been continually enriching it with new features. The Cart API offers improved performance, scalability, and a richer feature set including subscriptions, product bundles, and contextual pricing. Additionally, it integrates with Shopify's web checkout for further customization using Shopify Functions and UI extensions.

The Checkout Sheet Kit, compatible with Android, Swift, and React Native, streamlines mobile app development by integrating a fully-featured web checkout. This eliminates the need for a separate checkout build, reducing maintenance while preserving all customizations and business logic.

Action Required:

Follow the Cart API Migration Guide to update any application calling Admin REST API or Storefront GraphQL API checkout endpoints prior to 2025-04 to utilize the Cart API or Checkout Sheet Kit to avoid disruption.

If you have questions, please utilize the feedback repository.

As of 2024-04, OrderTransaction.receipt will be removed from the Admin GraphQL API. The field has been deprecated since 2019-04 and is replaced by OrderTransaction.receiptJson

Both fields contains the same data but in different formats. receipt was returning a Ruby hash formatted as a string, while receiptJson is returning JSON.

Standardizing around JSON-formatted receipts will make it easier for developer to build consistent integrations and removing duplicate fields will simplify our API.

Learn more about the change in the OrderTransaction GraphQL API documentation

As part of the GraphQL Storefront API 2024-04 API release, we've updated the cartNoteUpdate API to make the note argument required.

Learn more about the Cart object on Shopify.dev.

As of GraphQL Admin API version 2024-04, the following Customer sort keys have been deprecated: LAST_ORDER_DATE, ORDERS_COUNT, TOTAL_SPENT. Ordering customers by these attributes is available when filtering customers using segments.

Learn more about customer segmentation on Shopify.dev.

As of 2024-04, you can use the metafieldsDelete mutation to delete up to 25 metafields at once.

Learn more about metafields on Shopify.dev.

As of Admin API 2024-04, we are removing the following fields and mutations:
- InventoryLevel.available
- InventoryLevel.incoming
- InventoryLevel.deactivationAlertHtml
- Mutation.InventoryAdjustQuantity
- Mutation.InventoryBulkAdjustQuantityAtLocation

After building new fields to handle inventory quantities other than available, new fields and mutations that can handle all quantities were needed and released in 2023-01.

InventoryLevel.available and InventoryLevel.incoming should be replaced with InventoryLevel.quantities.

InventoryLevel.deactivationAlertHtml should be replaced with InventoryLevel.deactivationAlert.

Mutation.InventoryAdjustQuantity and Mutation.InventoryBulkAdjustQuantityAtLocation should be replaced with Mutation.InventoryAdjustQuantities or Mutation.InventoryMoveQuantities.

For those still using these fields on unstable, they will continue to work until 2024-04 is no longer supported.

More information on how to use these new fields can be found here

As of 2024-04 version Admin GraphQL API, you can update inventory_management boolean value on the FulfillmentService object using the [fulfillmentServiceUpdate mutation]((https://shopify.dev/docs/api/admin-graphql/2024-04/mutations/fulfillmentServiceUpdate) .

Learn more about inventory_management argument on Shopify.dev.

As of Admin version 2024-04 , there cannot be multiple of the same fulfillment_order_id within the line_items_by_fulfillment_order param for the REST "Creates a fulfillment for one or many fulfillment orders" API and GraphQL fulfillmentCreateV2 mutation.

Please combine any payload with the same fulfillment_order_id into one group.

The fulfillmentOrdersOptIn field on the FulfillmentService GraphQL and REST API objects, along with the related mutations and endpoints, is being deprecated as the migration to the Fulfillment Orders API has been completed. All properly functioning fulfillment services now have the fulfillmentOrdersOptIn field set to true.

In the 2024-04 API version, the fulfillmentOrdersOptIn field becomes nullable and defaults to true in the fulfillmentServiceCreate mutation and the Create Fulfillment Service REST endpoint. This field will be removed from the mutation input and the REST endpoint parameters in the subsequent API version (2024-07). To prepare for the 2024-07 API version release, stop supplying the fulfillmentOrdersOptIn parameter when creating a new fulfillment service.

As of 2024-04, we're removing the deprecated productDuplicateAsync mutation. The mutation was deprecated since 2023-07 version.

Use the productDuplicateAsyncV2 mutation instead.

As of API version 2024-04, you can retrieve a subset of fulfillment orders which are assigned to locations owned by the app performing the request but have not been requested for fulfillment so far.

The assignment_status parameter in the assignedFulfillmentOrders query can now accept a value of FULFILLMENT_UNSUBMITTED for filtering in addition to the existing FULFILLMENT_REQUESTED, FULFILLMENT_ACCEPTED, and CANCELLATION_REQUESTED filter values.

As of GraphQL Storefront API version 2024-04, we are adding support for query contextualization for B2B buyers via the @inContext directive. This allows developers to query the products and prices a B2B buyer may have for a particular company location.

Developers will also be able to query associated volume pricing and quantity rules, and work with a Cart that is aware of B2B specific rules and pricing.

Developers will also be able to query a purchasing company associated with a cart.

Learn more about B2B on Shopify.dev.

As of the 2024-04 release of the GraphQL Customer API, you can now query for a customer's subscription contracts using the subscriptionContracts or subscriptionContract fields.

This allows developers to query for all subscription contracts belonging to a customer, or to query for a specific subscription contract.

Learn more about querying for a customer's subscription contracts on Shopify.dev.

As of 2024-04, Added the following fields to the SubscriptionBillingAttemptErrorCode enum

• InsufficientFunds
• PurchaseTypeNotSupported
• Paypal Error
• CardNumberIncorrect
• FraudSuspected

Additionally, the following payment error code mappings have changed: * “Insufficient Funds” has been removed from “Invalid Payment Method” and now receives its own billing attempt error * “Pick up card” has been removed from “Payment Method Declined” and is now classified as “Fraud Suspected” * “Invalid Item Total” has been added to “Payment Method Declined”

And the following codes from payment processors have changed:

• Braintree

  • 2007 now maps to “Card Number Incorrect”
  • 2014 now maps to “Fraud Suspected”
  • 2105 now maps to “Transient Error”
  • 2106 now maps to “Transient Error”
  • 2107 now maps to “Invalid Payment Method”
  • 2108 now maps to “Invalid Payment Method”

• Paypal

  • 10417 now maps to “Paypal Error General”

• Stripe

  • cardnotsupported now maps to “Invalid Purchase Type”
  • invalid_account now maps to “Card Number Incorrect”
  • invalid_amount now maps to “Payment Method Declined”

As of version 2024-04 of the Admin API, you can use the checkoutBrandingUpsert mutation to configure two new color schemes: scheme3 and scheme4.

With this change, up to four color schemes can be configured and used in different sections.

Learn more about these new color chemes here

As of version 2024-04 of the Admin API, you can use the checkoutBrandingUpsert mutation to configure styling for the header and footer of your checkout.

With this change, header and footer sections can now be customized with color and spacing controls.

You can learn more about customizable header and footer in the GraphQL Admin API docs.

The new customizable fields are colorScheme and padding.

Shopify has introduced a public product taxonomy, serving as an open-source, standardized, and global classification of products sold on Shopify. This taxonomy, composed of product categories, attributes, and attribute values, is utilized across Shopify and integrated with numerous marketplaces. You can view the latest product taxonomy on our taxonomy explorer.

The new product taxonomy is now available in our public API with the 2024-04 release. This feature allows developers to navigate the taxonomy tree for categories, attributes, and values.

In order to support this change a number two existing APIs have been deprecated and replaced in favor of queryRoot.taxonomy.categories

• queryRoot.productTaxonomy
• queryRoot.productTaxonomyNodes

Additionally the following changes have been made:

• The ProductTaxonomyNode type has been replaced with a TaxonomyCategory type.
• The productCategory field on Product has been deprecated and replaced by category. This field directly references the new TaxonomyCategory type.

Orders with payment terms no longer always include an OrderTransaction when created from a Draft Order. Going forward, the transactions field on these Orders will be treated as an output that provides specific information about payments and other financial events related to the order, rather than as an implicit signal or side effect of creating an order from a draft.

If your app depends on implicit OrderTransactions that are added by creating an order from a draft, then you will need to switch to alternative options, for example recording payments or payment methods on an order to create an OrderTransaction.

Introducing Pickup Points, a new Shopify Function that enables developers to build custom apps for Plus shops that offer pickup points in checkout to locations like post-offices and parcel lockers.

Developers can integrate third-party pickup locations from any network of their choice, customize delivery information based on business logic, and define location-based pricing.

Pickup Points is only available for Shopify Plus merchants.

We want your feedback! Try Pickup Points early and share feedback that will directly guide development. To request access, contact us at pickup-point-generator-early-access@shopify.com.

Visit the developer documentation for more information.

We are changing how trials can be configured on your app listing:

• Trials will now be plan-level rather than app-level
• Free plans can no longer have a trial associated with them as they should not be time bound
• The change applies to apps with recurring monthly/annual subscription plans
• The change does not impact apps that are listed as completely free, or free to install

This update gives you more control on how you market trials on the App Store.

Shopify has auto-filled the app-level trial data to each plan card based on the last app listing submission form configuration. Please update these default values in the app listing submission form if you have plans with different trial lengths.

There is a grace period before plan-level trial changes appear on Shopify App Store app listing pages, which will happen on April 29th. This grace period does not apply to other fields in your app listing submission form, which you can still edit and update in real-time.

To modify trial durations, manage your app’s listing in the Partners Dashboard under the Distribution tab. Learn more about configuring your app listing on Shopify.dev.

Get your apps published faster with our streamlined app review experience. It provides a clear, guided process that ensures you’ve checked off some key requirements before submitting and contextual guidance that reduces rework. You'll know exactly where you are in the process at a glance with actionable statuses that let you know what to expect next.

Learn more about the app submission process on Shopify.dev.

As of 2024-04, we are making it easier to use our External Marketing API by removing old deprecated values and exposing is_external as a value.

Breaking Changes

• The deprecated follow_up, receipt, display, search, seo and direct marketing tactics are being removed from the 2024-04 API version. See the MarketingTactic documentation for which tactics should be used instead.

Non-breaking Changes

• The is_external attribute can be fetched in the MarketingActivitiesquery to know if an activity was created and is managed by an external platform.

Network access for Shopify Functions is now available in early access. Primarily for merchants on Shopify for enterprise, this powerful new capability allows merchants to integrate Shopify with their own commerce ecosystem and fetch information from external services.

Network access is currently supported in early access on the following Shopify Functions:

• Cart and Checkout Validation
• Local Pickup Delivery Option Generator
• Pickup Point Delivery Option Generator

To learn more about Network access for Shopify Functions, please refer to the documentation.

As of REST API 2024-04, we’re deprecating the Reports resource.

The REST API Reports resource used to create custom reports in analytics has been deprecated. You can still use previous, stable versions of the REST API to continue creating custom reports in admin for the time being.

As of API version 2024-07, the variant image field in the product_feed/incremental_sync and product_feed/full_sync webhooks will no longer fall back to the product's first image when an image has not been explicitly set for the variant. Instead, no image will be returned.

If this change is undesirable for your use case, you can replicate the old behavior by assigning the first product image to the variant when it is null after receiving the webhook.

In May 2022, Shopify announced that unpublished apps would no longer be supported. To ensure merchant trust and security, all apps must now pass Shopify App Store review to guarantee the best app experience including branding, installation, onboarding, functionality, and quality. Developers with unpublished apps are required to take action by either converting them to public apps by meeting Shopify App Store requirements and submitting them to Shopify for review, or sunsetting their unpublished apps.

Impacted developers will receive an email outlining next steps, including the deadline to submit your apps for review. Please ensure your contact information is up to date.

If your unpublished apps have not been submitted for review or sunset by the deadline, these apps will have their API access revoked and will be uninstalled from all merchant stores. Developers will be notified at least 60 days prior to any changes being made.

For more information, please visit our documentation.

To enhance the security of merchant and customer information and provide additional protection for customer data, we’ve implemented level 2 protected customer data requirements for partners and developers, alongside new timeout parameters and login requirements to the Order Status Page.

After an order is created, customers can access the Order Status Page without logging in for a limited timeframe and/or number of browser visits. After these timeout parameters have been reached, customers must provide credentials to access the Order Status Page, such as phone number, email address, order number, or by using passwordless login.

We recommend that partners and developers who send transactional SMS on behalf of merchants include the customer’s order number alongside any links to the Order Status Page.

Learn more about changes to the Order Status Page in our developer documentation.

As of version 2024-04 of the GraphQL Admin API, a new optional field title has been added to validationCreate and validationUpdate. This will allow you to create multiple instances of the same Validation function where the unique title will help merchants easily differentiate between them.

As of version 2024-04 in the GraphQL Admin API, new fields createdAt, updatedAt, and isFulfillmentService have been added to the Location object.

Learn more about Location fields on the GraphQL Admin API at Shopify.dev.

We are requiring apps to meet Level 2 Protected Customer Data Requirements in order to acess the field order.statusPageUrl on the Admin GraphQL API and on the Admin REST API. This change is applicable to all API versions. We recognize that this may be a breaking change for some apps. However, this change is necessary to ensure the protection of customer data.

Learn more about Protected Customer Data, including the actions you need to take to enable existing apps to continue to have access to order.statusPageUrl on Shopify.dev.

With the latest version of App Bridge, you can use the ui-save-bar component and the SaveBar React component to declaratively control the contextual save bar, including setting loading and disabled states of the Save and Discard buttons. Learn more about it in the documentation.

With the latest version of App Bridge, you can use the src attribute with the ui-modal component and the Modal React component to display content from the provided URL. Learn more about it in the documentation.

As of version 2024-04, you can use the GraphQL Admin API to query a shop's Shopify POS cash tracking sessions. The API returns cash tracking data for locations that have a Shopify POS Pro subscription

Below are some examples of the data that's available on the new CashTrackingSession type:

• Opening and closing times, and the staff member who performed each action
• Adjustments to add or remove cash from the cash drawer, and the staff member who performed each action
• Notes attached to the actions listed above
• Aggregations, such as the total cash sales, total cash refunds, and the net cash sales that were processed during the cash tracking session
• Discrepancies between the amount counted in the cash drawer and the amount expected

To find out more, see CashTrackingSession in the GraphQL Admin API reference.

As of version 2024-04 of the Storefront API, you can use new attributes of the Filter and FilterValue objects to create visual filters for your custom storefront.

We are adding FilterValue.swatch intended for color and pattern swatches and FilterValue.image for more detailed imagery. Use the new Filter.presentation attribute to know the intended display of each filter.

Merchants must use Shopify's Search & Discovery app to set visual filters for their store.

As of March 13, we added the following updates to POS UI Extensions:

• Added a discounts property to the Cart object, which includes all cart discounts.
• Added addCartCodeDiscount to the Cart API, which allows the UI extension to add a code discount. The existing applyCartDiscount will still function for code discounts, too.
• Added remove AllDiscounts to the Cart API, which allows the UI extension to remove all cart discounts.
• Added a listHeaderComponent to the List component.

All of the changes are available for POS UI extensions version 1.7.0 and POS app version 9.4.0. See the version log for all version details.

As of Admin GraphQL API version 2024-04, the isGiftCard field that was present on DraftOrderLineItem and CalculatedDraftOrderLineItem is now also present on:

• ExchangeCheckoutLineItem
• ExchangeV2LineItem
• LineItem
• LineItemMutable

It is now preferable to use this field to check whether a line item is a gift card instead of using the fulfillment service.

As of March 13th, 2024, net new Shopify App Store apps must use the latest Shopify App Bridge by adding the app-bridge.js script tag to the <head> of each document of your app.

As of version 2024-04 of the Admin GraphQL API, the subscriptionContractAtomicCreate and subscriptionContractCreate mutations will return a new error code CUSTOMER_REDACTED when creating new subscription contracts for customers scheduled for redaction or have been redacted.

Learn more about customer redaction here.

You can now use a Liquid swatch drop to create visual filters for your Online store themes.

The filter value display drop is now considered deprecated in favour of swatch. The display drop will continue to function as it does today for backwards compatibility in merchants’ themes.

As of Storefront API's 2024-04 release, you can use cart.deliveryGroups.groupType to determine whether a delivery group represents a single delivery (ONE_TIME_PURCHASE) or is a recurring delivery (SUBSCRIPTION)

You can now collect the id of a customer within the order object of the checkout_completed customer event. This gives you more customer insights to improve marketing campaign targeting and analytics.

Learn more about the checkout_completed event in our developer documentation

• Clarified webhooks-related terminology in the Webhooks Overview page to make it easier to get started
• Updated accuracy of Limitations on webhook delivery guarantees
• Updated technical implementation accuracy of Avoiding debounces

Hydrogen v2024.1.3 is out today. The March 2024 Hydrogen release contains several new features:

• Hydrogen now includes experimental support for Vite.
• A new env push__unstable command to upload local environment variables to Oxygen from the command line
• You can now get comments on GitHub PRs when Oxygen creates a preview deployment on your connected storefront.

In addition to these new features, Hydrogen 2024.1.3 includes a range of updates, performance upgrades, and bug fixes, including an upgrade to Remix v2.8.

Check out our full Hydrogen March 2024 release blog post for more details. And please drop your comments, feedback, and suggestions in GitHub Discussions!

Developers must create a video demo that illustrates how to use their app, as a now mandatory requirement for submission.

New apps that are in a Draft status will be asked to provide this prior to submitting for initial review. Submitted apps that are already in initial review may be asked to provide one before they can be published. Published apps that become Delisted may be asked to provide one before they can become published again.

This requirement will substantially help our review team to understand app flows and functionality during testing, and will speed up the review process.

Returns will now create corresponding Sales entries.

As of 2024-04, SalesAgreements made as part of a return will have the type ReturnAgreement. The OrderActionType enum can have a type of RETURN.

As of 2024-04, the SaleLineType enum can now have a type of FEE. Fees can be of the type RestockingFee or ReturnShippingFee, representing corresponding fees on a return.

Any Admin API consumers of OrderActionType or SaleLineType will need to accept this new enum value. Previous versions of the Admin API will show these values as "UNKNOWN".

You can now view ExchangeLineItems on their associated return. This provides context on returns that will be resolved with an exchange.

A new webhook "returns/update" has been added. This webhook will fire when fees or line items on a return are modified or removed. All returns webhooks will now display restock and shipping fees, as well as exchange line items.

Dispositions can no longer be created for canceled reverse fulfillment orders. This will result in the new error code INVALID_STATE.

Restocking returned items in the Admin will now create ReverseFulfillmentOrderDispositions.

As of Admin GraphQL API 2024-04, there will be new fields exposed on InventoryItem (and related input types) and some fields on ProductVariant (and related input types) that were marked as deprecated.

For InventoryItem and related input types:

• InventoryItemMeasurement and InventoryItemMeasurementInput were added as new types, with a single field: weight (which is a Weight type).
• measurement was added as a field to InventoryItem.
• harmonizedSystemCode, measurement, and requiresShipping were all added as input fields to InventoryItemInput.

For ProductVariant and related input types:

• fulfillmentServiceEditable, weight, and weightUnit were all marked as deprecated on ProductVariant.
• harmonizedSystemCode, requiresShipping, weight, and weightUnit were all marked as deprecated on ProductVariantInput and ProductVariantBulkInput.

These changes are all in support of removing long-deprecated fields on ProductVariant and removing the duplicated fields between ProductVariant and InventoryItem.

Developers can now generate even more demand for their apps by showcasing them on the category and subcategory pages of the Shopify App Store.

Learn more about category page ads on Shopify.dev.

As of 2024-04, you can filter the results returned by the Product.media connection to a specific media_type.

Using the Product.media connection enables you to retrieve all the media that's associated with a product including images, video, and 3D models or filtering to a specific media_type such as IMAGE. We recommend that developers migrate their apps from the Product.images connection to Product.media.

As of GraphQL Admin API version 2024-04, you can add new shipping lines or remove existing shipping lines when editing an order. You can also continue to query removed shipping lines.

The mutation orderEditAddShippingLine allows you to add a new, custom shipping line to an existing order. The mutation orderEditRemoveShippingLine allows you to remove existing shipping lines from an order. The mutation orderEditUpdateShippingLine allows you to update the attributes of a newly added shipping line before committing the order edit. The new field shippingLine.isRemoved allows you to determine whether a shipping line has been removed. The new parameter includeRemovals on the connection order.shippingLines allows you to query removed shipping lines. The default value for this parameter is false, so removed shipping lines will not be returned by default.

For REST API users, removed shipping lines will continue to be returned in the payload of the Order resource. As of API version 2024-04, you can determine whether a shipping line has been removed by checking the value of the new attribute is_removed.

For consumers of Order webhooks, removed shipping lines will also continue to be returned in the payload. As of API version 2024-04, the payload for shipping lines will have a new key is_removed. You can consume the order/edit webhook to be notified when shipping lines have been added or removed from an order.

For more information about editing shipping lines, visit the tutorial on editing an existing order with the Admin API.

As of 2024-04, you can now query the OrderPaymentStatus object to obtain information about its corresponding transactions.

As of 2024-04, you can specify custom amounts to be charged from a vaulted card through the OrderCreateMandatePayment mutation for Shopify Plus merchants.

As of version 2024-04 of the Admin GraphQL API, you can now void a transaction through the transactionVoid mutation.

The @defer directive is now available in developer preview, allowing developers to prioritize part of a GraphQL query without having to make multiple requests to fetch the remaining information. Clients can make a single request and data will be received in a stream of responses.

This developer preview will guide our decision on the inclusion of this directive in the Storefront API. It will also provide insights into whether clients can effectively support the @defer directive in their implementations, as we are planning the introduction of fields that require mandatory use of @defer.

Test out the defer directive today by enabling the developer preview and following our tutorial . We value your input, please share your feedback on Github.

React developers can start using the App Bridge React v4 via NPM. This optional NPM package works with the required App Bridge library loaded via the <script> tag.

For those already using App Bridge React v3 or lower, please refer to the migration guide for how to upgrade.

As of the 2024-04 version of the GraphQL Admin API, you can use the new argument withCodeDiscounts on the order.lineItem.discountedTotalSet field to include or exclude line item discounts originating from a discount code. The current behaviour of discountedTotalSet is to exclude code based discounts and as such, the default value for this option is false so there will be no change required for clients who want to continue to have them excluded.

See the documentation for discountedTotalSet on Shopify.dev. The argument is already available on the unstable Admin API.

As of February 20, 2024, the returnCreate mutation and the returnApproveRequest mutation will create return sales on the order. Each returned item will create a product type return sale. Previously, these mutations did not create sales.

This new behavior is applied to all non-Plus merchants, and Plus merchants who have enabled Exchanges capabilities using Test Drive. Learn more about feature test drives in our Shopify help docs

To keep track of line item or value changes to the order due to returns, we will soon provide more information on subscribing to enhanced Return related webhooks. Stay tuned for these details.

Related changes

Return fees as RETURN type

When a merchant adds return fees to a return using the admin, return fees will show up as a RETURN OrderActionType on a SalesAgreement.

LineItem.currentQuantity and LineItem.refundableQuantity definition changes

Previously, both LineItem.currentQuantity and LineItem.refundableQuantity returned identical numbers. They represented the total quantity of the line item minus the quantity that had been removed.

The definitions of these properties have been updated:
- LineItem.currentQuantity: This property now considers returns that are in progress, even if they haven't been refunded yet. CurrentQuantity will now be the line item's total quantity minus the removed or returned quantity.
- LineItem.refundableQuantity: It now represents the line item's total quantity minus the refunded quantity, not the removed quantity. This indicates the quantity of line items that are available for a refund, including items in a return.

These changes affect all currently supported APIs (GraphQL, REST, liquid, etc.)

Use ReturnRefund when refunding a return line

Use the returnRefundGraphQL mutation when refunding a line item on a return to guarantee accurate sales ledger entries. We strongly encourage developers to migrate away from using refundCreate and POST refund to refund return line items due to potential inaccuracies in the sales ledger due to both returns and refunds producing product type return sales.

As of February 15, we added the following updates to POS UI Extensions:

• Added optional bannerProps to the CameraScanner component, which allows the UI extension to surface banners within the context of the CameraScanner.
• Added fetchPaginatedProductVariantsWithProductId to the ProductSearch API, which allows the UI extension to fetch pages of variants for a product by ID.

All of the changes are available for POS UI extensions version 1.6.0 and POS app version 9.2.0. See the version log for all version details.

Product duplication now includes variant metafields. Previously, variant metafields were ignored when products were duplicated. Products can be duplicated via admin or GraphQL

Starting from April 2024, the Order risk REST and GraphQL APIs are deprecated:

• admin-rest / order-risk
• admin-graphql / field-order-risks
• admin-graphql / field-order-riskLevel

Clients are advised to use the new Risk Assessments API instead:

To create assessments, you can now use the new mutation orderRiskAssessmentCreate.

Additionally, a new webhook topic is available: ORDERSRISKASSESSMENT_CHANGED

As of version 2024-04 of the Admin GraphQL API, you can read the additionalInformation object value on the deliveryMethod object using the fulfillmentOrder query .

Learn more about additionalInformation argument on Shopify.dev.

Help merchants with post-purchase customer service by enabling them to issue, track, and report accurately on store credit using Shopify’s new Store Credit Primitive and API, available in developer preview.

Streamline checkout, customer support and workflows, with a single, reloadable store credit balance for customers. Start using the store credit GraphQL API today to add key functionality that enables differentiation between gift cards and store credit, the linking of store credit directly to a sole customer, and more.

Get started

We've introduced OAuth2 Token Exchange and Shopify managed install to eliminate screen flickering due to full page redirects on app load and provide uninterrupted & faster embedded app loading and installs.

To avoid unnecessary redirects and page flickers during the app installation process, configure your app's required access scopes using Shopify CLI. This allows Shopify to manage the installation process for you.

OAuth2 Token Exchange allows embedded apps to exchange session tokens for access tokens. This avoids the multiple requests and redirects as a result of OAuth authorization code grant, making it easier to retrieve both online and offline access tokens.

Use Shopify CLI to generate a starter app, which uses token exchange and leverages Shopify managed install. For existing Remix apps, please refer to our migration guide.

You can now use Admin UI extensions to provide a user interface for merchants to configure your Cart and Checkout Validation Functions.

Additionally, merchants on any plan can now use validation functions provided by public apps distributed through the Shopify App Store.

Learn more on Shopify.dev.

The Checkout Branding API now supports container styling for sections in the main and the order summary areas of checkout. This change is available in the 2024-04 release candidate.

These changes will give merchants more control over section corner radius, border styles, color scheme, spacing and shadow customizations within or between sections. We will be releasing an update to customize the header and footer sections in a subsequent release.

Learn more through our reference documentation.

As of 2024-01-31, Checkout Extensibility enables merchants to customize checkout's header and footer with their brand and navigation intent.

Use the GraphQL Admin API's checkout branding to: * Hide the logo, breadcrumbs, default footer content, and Back to cart links * Control the footer position and alignment

Use checkout UI extensions to add content and replace hidden content, with the new header and footer extension targets in Checkout and the Thank you page.

Learn more on Shopify.dev.

You can now use the Discounts Allocator Function API in Developer Preview to implement custom logic for distributing discounts across multiple products or orders.

This new API allows you to define your own logic for how discounts are distributed, enabling the implementation of merchant-specific discount strategies.

Learn more about the Discounts Allocator Function API in our developer documentation.

Theme Check 2.0 marks the grand unification of Shopify theme developer tools. Now, you can use all Language Server Protocol (LSP) features in the admin code editor, on the Shopify Liquid VS Code extension, and on Shopify CLI.

Here's what's now available everywhere:

• Hover documentation support
• Code completion for theme, section, and block settings
• Code completion for theme translations
• Code completion for HTML tags, attributes, and values
• Code completion for Liquid filters, objects, and tags
• Enhanced auto-closing pair user experience
• Automatic support for new Liquid tags, filters, and objects

We're excited to see how these changes will enhance your theme development process. Learn more about Theme Check 2.0 on Shopify.dev and happy coding!

You can now subscribe to select DOM events with the Web Pixels API, including input_changed, input_blurred, input_focused, form_submitted, and clicked.

These new events will help merchants better understand how visitors are engaging with their online stores.

Learn more about Web Pixels on Shopify.dev.

With the latest release, Hydrogen and Oxygen make the path to production more seamless than ever. We’ve added new developer tools so you can more easily debug and optimize your build before you deploy:

• Subrequest profiler: get a more detailed look at what’s happening inside your Remix loaders — identify query waterfalls, inefficient API calls, and suboptimal caching behavior.
• Error console: stack-trace errors back to your source code, right from the Shopify admin, so you can get right to the fix.
• CLI deploys: Deploying to Oxygen is easier than ever. Run the new deploy command to create deployments from your local dev environment, or build your own CI/CD processes on any platform.
• End-to-end testing support: Automatically and securely run E2E tools like Playwright or Cypress on every Oxygen deployment with our new E2E testing tokens.
• Shareable storefront previews: Share progress with colleagues and stakeholders — even if they don’t have access to your Shopify Admin — with our new revocable, token-based shareable links.
• Runtime mirroring: Hydrogen’s development server runtime is now nearly identical to production Oxygen, and now serves assets from a separate domain to better replicate how Shopify’s CDN works.
• Bundle insights: analyze your worker bundle file to find bloated dependencies, optimize your bundle size, and reduce cold start times, so your app stays fast over time.
• CLI upgrade command: Stay up-to-date with the latest version of Hydrogen and Remix with h2 upgrade command from your CLI. Your project’s critical dependencies will all be updated to the latest version, along with a custom migration guide.
• It’s easier than ever to learn Hydrogen, with our refreshed docs, and a new suite of examples.

Learn more about our latest release in detail.

You can now integrate the Customer Privacy API and the Shopify Privacy & Compliance app into your Hydrogen storefront, making it easier to comply with data protection laws and increase customer trust. This allows consent to flow to Shopify so it can be honored on Pixels, Checkout and other services.

The Shopify App Store is introducing structured app category details to make it even easier for merchants to evaluate relevant apps within the same category. Starting today, category details can be added for apps classified under:

• Product reviews
• Dropshipping
• Product bundles
• Subscriptions
• Loyalty and rewards
• SEO
• Page builder
• Pop-ups
• Discounts
• Email marketing

Using this structured data, merchants will soon be able to see this information on the app details page, as well as on the compare apps page

Learn more about how App Category Details work at shopify.dev

When you define the permissions your app requests, they will now show up in a new "Data Access" section on your app details page to help build merchant trust.

Your installation flow will also be updated to a new installation modal, rather than a full page experience, which will streamline the install process for merchants.

Shopify’s Checkout Sheet Kit enables you to provide the world’s highest converting, customizable, one-page checkout directly within a mobile app. Today we are happy to announce that the v1.0.0 of Checkout Sheet Kit for Android, React Native and Swift is officially available and no longer in developer preview. The libraries are open-source and ready for you to start building.

More information can be found in documentation as well as in the Github repositories linked above.

Now in developer preview, we’ve introduced new GraphQL product APIs that support 2000 variants, allowing for support of more complex catalogs.

Learn more here.

Merchants can now discover your app in the new AI-powered guided search that supports merchant’s natural language queries, and provides insights to help them make a better informed app decision. This can be accessed through the search bar in the Shopify App Store under the "Ask about apps" section. Keep your listing accurate and up-to-date with the solution that you provide to help the right merchants find your app.

Try it now

An upcoming release affects the app configuration deployment process using Shopify CLI, which includes breaking changes that require your attention.

Effective January 31, 2024, we're introducing an improved way to release your app configuration and extensions together using the shopify app deploy command. With this update, you can version and roll back changes to your app configuration as part of app versions!

Upcoming Breaking Change Details: The Shopify CLI shopify app config push command will no longer be supported in any CLI version. Instead, you should use the shopify app deploy command to release your app configurations and extensions.

Next steps starting January 31, 2024:

• Developers using shopify app config push to release app configuration need to update to the latest Shopify CLI version and use shopify app deploy instead.
• Developers using shopify app config push in CI/CD workflows need to update their deployment scripts to remove this command.

Detailed migration instructions will be provided in app configuration documentation at the time of release on January 31.

You can now subscribe to compliance topics using you app's TOML configuration file and use PubSub or Eventbridge URIs as your subscription endpoint.

Learn more about mandatory compliance topics here.

We've introduced the following changes to improve and update the App Design Guidelines:

• The full-screen mode guidance has been revised and renamed to max modal.
• The admin app block directive regarding the summary property has been removed as it is no longer applicable.

With the latest version of App Bridge, you can use the POS API. This provides the ability to retrieve the POS user, device, and location data, while also interacting with the cart and closing the app.

As of 2024-04, the Abandonment.isFromCustomStorefront field has been released into stable version.

In preparation for supporting IPv6 on storefront domains, merchants and partners should update any third-party tools, such as firewall rules, to allow traffic in the CIDR range 2620:127:f00f::/48 and 2620:127:f00e::/48 by January 16, 2024.

Outbound traffic from Shopify will not be affected.

As of version 2024-01, you can use the GraphQL Admin API to get and set a firstName and lastName on the CompanyAddress.

As of 2024-04 the following fields on the MarketWebPresence object will no longer return locale strings and will instead make use of the ShopLocale type:

• defaultLocale
• alternateLocales

We’re making this change as it allows callers to query for more information regarding locales on a market, such as whether it is published or primary. Please ensure to update your API calls using MarketWebPresence.defaultLocale or MarketWebPresence.alternateLocales to use the ShopLocale type.

Learn more about the MarketWebPresence object on Shopify.dev.

As of Shopify CLI version 3.53+, you can use GraphiQL in the CLI while running app dev by simply pressing the g hotkey.

This GraphiQL instance uses your app's credentials, working with the same data and access scopes, ensuring that what works in GraphiQL will work exactly the same in your app. We expect this feature to streamline how you create and edit GraphQL queries.

Learn more about in our documentation.

With the latest version of App Bridge, you can use the filter query option with the Resource Picker API to filter resources without showing the query in the Resource Picker search bar.

As of the 2024-01 version of the REST Order APIs, channel_liable field on the TaxLine has been updated to reflect the value indicated by the app. The behaviors now align between the REST and GraphQL endpoints.

The channel_liable field lets developers inform merchants that another party is responsible for sales tax remittance, which then helps merchants better understand the tax that they are responsible for.

channel_liable can contain the following values: - true indicates that the channel is responsible for remittance of the tax line - false indicates that the channel is not responsible for remittance of the tax line

If the channel_liable field is not populated, a value of false will be assumed.

As of API version 2024-01, we've added the CAPABILITY_VIOLATION error code to the MetafieldsSetUserErrorCode enum. This error code is returned if you attempt to update a metafield in a way that doesn't conform to the enabled capabilities.

Previously, the Cart Transform Function API allowed percentage based adjustments to the cost of a bundle when using expand operations. The weight price algorithm would then allocate the bundle price to its component lines based on the weight of each component line (unit price * quantity).

As of the 2024-01 Cart Transform Function API version, expand operations will also allow you to set fixed prices on each component of the bundle, resulting in a bundle price that is the sum of each component. Additionally, the expand operation will now allow you to define a custom title and image for each parent line item. This gives you more control over bundle pricing and enables bundles to be used for add-on products.

A new update operation will allow you to override the price, title, and image of a given line item. This gives you more more flexibility to make additional customizations to items in the cart. The update operation is only available for Plus merchants.

To see what operations are available for a shop, you can query the cartTransform field on ShopFeatures.

Finally, the CartTransformCreate mutation in the Admin API now supports a blockOnFailure field that determines if cart and checkout operations should be blocked if the CartTransform function fails to run. This can be used as a safeguard if the Cart Transform is considered a critical component in resolving merchandise attributes (e.g. price, title, image).

More information can be found in the Cart Transform API documentation and the CartTransformCreate mutation.

As of 2024-01 version in the admin GraphQL API, you can specify whether to include translations when calling the productDuplicate mutation. When this optional argument is passed in as true, all translations that are saved on the product, its variants, and its metafields are copied over to the new product.

As of Admin API 2024-01, you can use the checkoutBrandingUpsert mutation to reset branding settings to their default state without resetting each leaf field explicitly. It is now possible to pass in a null value to the checkoutBrandingInput argument to clear all of the branding settings, which will revert the branding of the Checkout to its default state.

Note that for all API versions, it is also possible to pass in a null value to a non-leaf subfield, for example design_system.colors.schemes.scheme1, to reset a given group of parameters.

Both of these changes enhance the usability of the Checkout Branding API by allowing to easily reset groups of branding parameters.

As of API version 2024-01, we fixed a bug that had allowed refunds specifically against a requested return. Refunds are blocked on returns with a REQUESTED status.

• Learn more about the status of a return on Shopify.dev.
• Learn more about requesting returns on Shopify.dev
• Learn more about self serve returns on the help center

As of 2024-01 the OrderTransaction endpoint now exposes the multiCapturable field, to inform whether a transaction can be captured multiple times.

Learn more about OrderTransaction.

As of 2024-01, the line_items field on AbandonedCheckout GraphQL API will be available to public.