Checkout This Guide to Shopify’s Checkout API

Understanding Shopify’s Checkout Process and APIs in 2026

Shopify create checkout — in 2026, this means working with the Storefront Cart API using GraphQL to create and manage cart sessions that redirect customers to Shopify’s hosted checkout. The old Checkout API was officially deprecated and shut down on April 1, 2025. Any store or app still using the legacy Checkout API endpoints stopped functioning on that date.

Here’s what you need to know for 2026:

• Current approach: Use the Storefront Cart API with GraphQL mutations to create and manage carts
• Deprecated (shut down April 1, 2025): The Checkout API (Storefront Checkout Mutations and REST Checkout Endpoints)
• Basic implementation: Send a POST request to /api/graphql.json with a cartCreate mutation, then use the cart’s checkoutUrl to redirect customers to Shopify’s hosted checkout
• Requirements: Public Shopify app with appropriate scopes, valid storefront access token, or Storefront API client credentials
• Checkout customization: Use Checkout UI Extensions for custom functionality, Shopify Functions for business logic, and the Branding API for visual design

Shopify’s checkout system processed over 6 billion orders globally in 2025, trusted by more than 700 million customers worldwide. As a developer or merchant, understanding how to create and customize the checkout experience is foundational to maximizing conversions and providing a seamless shopping experience.

The checkout page is where digital window-shoppers transform into paying customers, making it one of the most critical touchpoints in your e-commerce operation. Shopify’s checkout converts up to 36% better than competitors on average, and Shop Pay increases conversion rates by up to 50% compared to guest checkout. Understanding how to correctly implement and customize this flow directly impacts your bottom line.

I’m Cesar A. Beltran, Founder and CEO of Blackbelt Commerce with over 15 years of experience implementing Shopify checkout solutions for businesses of all sizes. My team has helped more than 1,000 merchants optimize their checkout flows to reduce abandonment and increase revenue. In this guide, I’ll cover everything that changed with the 2025 Checkout API deprecation, how to implement the current Cart API approach correctly, and the advanced customization options available in 2026.

The 2025 Checkout API Deprecation: What Changed and Why It Matters

If you’re maintaining a custom Shopify integration or app built before 2025, this section is critical. Shopify’s deprecation of the Checkout API on April 1, 2025 was one of the most significant developer-facing changes in the platform’s history.

What Was Deprecated

The following were shut down on April 1, 2025:

• Storefront API Checkout Mutations (e.g., checkoutCreate, checkoutLineItemsAdd, checkoutEmailUpdateV2)
• REST Admin API Checkout Endpoints
• All checkout object queries via the Storefront GraphQL API

Why Shopify Made This Change

The Checkout API was designed for an era of headless checkout—where third-party apps controlled the entire checkout UI and experience. Shopify’s evolution toward Checkout Extensibility (a model where Shopify hosts and controls the checkout while allowing targeted customizations via Extensions) made the old architecture obsolete.

The Cart API is more aligned with Shopify’s current architecture: merchants use the Cart API to manage what’s in the cart (products, quantities, discounts, attributes) and then redirect customers to Shopify’s hosted checkout via the cart’s checkoutUrl. Shopify handles the actual checkout flow, ensuring PCI compliance, Shop Pay compatibility, and conversion optimization that Shopify’s team continuously improves.

Impact on Mobile Apps

Mobile apps using the deprecated Checkout API needed to migrate to the Storefront Cart API before April 2025, or alternatively adopt Shopify’s Checkout Sheet Kit—a library compatible with Android (Kotlin), iOS (Swift), and React Native that provides a native checkout experience within mobile apps without custom checkout UI development.

The Storefront Cart API: Core Concepts for 2026

The Storefront Cart API works differently from the old Checkout API in several important ways. Understanding the conceptual difference is as important as knowing the technical implementation.

Cart vs. Checkout: The Fundamental Distinction

In the Cart API model:

• Cart: A mutable session managed via the Cart API. You add, remove, and update items; apply discounts; set customer attributes; and manage buyer identity—all through Cart API mutations.
• Checkout: Shopify-hosted, triggered when you redirect the customer to the cart’s checkoutUrl. You don’t create or manage the checkout directly—Shopify does.

This is a fundamental architectural shift. In the old Checkout API, you created and managed a checkout object directly. In the Cart API, you manage a cart object and then hand the customer off to Shopify’s checkout via a URL.

Core Cart API Mutations

Key Improvements in the Cart API

The Cart API isn’t just a replacement—it offers meaningful improvements:

Stackable discount codes: The Cart API’s cartDiscountCodesUpdate mutation accepts multiple discount codes simultaneously. The old Checkout API only allowed one discount code at a time. This enables more sophisticated promotional strategies.

Better buyer identity management: The cartBuyerIdentityUpdate mutation handles customer association, delivery address preferences, and international pricing in a unified mutation. The old API required multiple separate mutations to achieve the same result.

Persistent cart across sessions: Cart IDs can be persisted (in localStorage or cookies) and retrieved later, enabling “continue shopping” functionality without losing cart state.

Delivery address mutations: New mutations—cartDeliveryAddressesAdd, cartDeliveryAddressesUpdate, cartDeliveryAddressesRemove—allow managing delivery addresses before the customer reaches checkout, enabling faster checkout flows.

Privacy consent support: The Cart API supports consent information encoding directly in the checkoutUrl, ensuring privacy compliance flows carry through to Shopify’s checkout without breaking user consent management.

Implementing the Storefront Cart API: Step-by-Step

Step 1: Set Up Your Storefront API Credentials

To use the Storefront API, you need a Storefront access token. Create one from your Shopify admin:

1. Go to Shopify admin > Apps > Develop apps
2. Create a new app (or open an existing one)
3. Under “API credentials”, click “Configure Storefront API scopes”
4. Enable the required scopes: at minimum, unauthenticated_read_product_listings and unauthenticated_write_checkouts
5. Install the app and copy the Storefront API access token

Your API endpoint will be: https://your-store.myshopify.com/api/2025-01/graphql.json (use the current API version)

Step 2: Create a Cart with cartCreate

The cartCreate mutation initializes a new cart, optionally with line items, buyer identity, and discount codes:

mutation cartCreate($input: CartInput!) {   cartCreate(input: $input) {     cart {       id       checkoutUrl       lines(first: 10) {         edges {           node {             id             quantity             merchandise {               ... on ProductVariant {                 id                 title                 price {                   amount                   currencyCode                 }                 product {                   title                 }               }             }           }         }       }       cost {         totalAmount {           amount           currencyCode         }         subtotalAmount {           amount           currencyCode         }       }     }     userErrors {       field       message     }   } } 

Variables for this mutation:

{   "input": {     "lines": [       {         "merchandiseId": "gid://shopify/ProductVariant/YOUR_VARIANT_ID",         "quantity": 1       }     ],     "buyerIdentity": {       "email": "customer@example.com",       "countryCode": "US"     },     "discountCodes": ["FIRSTORDER"]   } } 

The response includes the cart.id (store this for subsequent mutations) and the cart.checkoutUrl (use this to redirect customers to checkout).

Step 3: Manage Cart Items

Adding items to an existing cart:

mutation cartLinesAdd($cartId: ID!, $lines: [CartLineInput!]!) {   cartLinesAdd(cartId: $cartId, lines: $lines) {     cart {       id       lines(first: 10) {         edges {           node {             id             quantity             merchandise {               ... on ProductVariant {                 id                 title               }             }           }         }       }       cost {         totalAmount {           amount           currencyCode         }       }     }     userErrors {       field       message     }   } } 

Updating quantity on an existing line item:

mutation cartLinesUpdate($cartId: ID!, $lines: [CartLineUpdateInput!]!) {   cartLinesUpdate(cartId: $cartId, lines: $lines) {     cart {       id       lines(first: 10) {         edges {           node {             id             quantity           }         }       }     }     userErrors {       field       message     }   } } 

Step 4: Apply Discount Codes

The Cart API supports multiple stackable discount codes simultaneously—a major upgrade from the legacy API:

mutation cartDiscountCodesUpdate($cartId: ID!, $discountCodes: [String!]!) {   cartDiscountCodesUpdate(cartId: $cartId, discountCodes: $discountCodes) {     cart {       id       discountCodes {         code         applicable       }       cost {         totalAmount {           amount           currencyCode         }         subtotalAmount {           amount           currencyCode         }       }     }     userErrors {       field       message     }   } } 

Step 5: Associate Buyer Identity

Associate a logged-in customer’s identity and preferences with the cart:

mutation cartBuyerIdentityUpdate($cartId: ID!, $buyerIdentity: CartBuyerIdentityInput!) {   cartBuyerIdentityUpdate(cartId: $cartId, buyerIdentity: $buyerIdentity) {     cart {       id       buyerIdentity {         email         phone         customer {           id           email           firstName         }         countryCode       }     }     userErrors {       field       message     }   } } 

Step 6: Add Cart Attributes (Custom Metadata)

Use cart attributes to pass custom data through to the order:

mutation cartAttributesUpdate($cartId: ID!, $attributes: [AttributeInput!]!) {   cartAttributesUpdate(cartId: $cartId, attributes: $attributes) {     cart {       id       attributes {         key         value       }     }     userErrors {       field       message     }   } } 

Variables example:

{   "cartId": "gid://shopify/Cart/YOUR_CART_ID",   "attributes": [     {"key": "Gift message", "value": "Happy Birthday!"},     {"key": "Source", "value": "email-campaign-2026-spring"}   ] } 

Step 7: Redirect to Checkout

Once the cart is configured, redirect the customer to checkout using the checkoutUrl from the cart object:

// JavaScript/React example const checkoutUrl = cart.checkoutUrl; window.location.href = checkoutUrl;  // Or open in a new tab window.open(checkoutUrl, '_blank'); 

The checkoutUrl can be retrieved at any point in the cart flow and will reflect the current cart state. Shopify handles everything from this point: payment processing, address entry, shipping selection, and order confirmation.

Advanced Cart and Checkout Customization in 2026

Checkout UI Extensions

Checkout UI Extensions allow merchants and developers to add custom functionality to Shopify’s hosted checkout using React components. As of 2026, available extension targets include:

• purchase.checkout.block.render — Add custom blocks anywhere in the checkout
• purchase.checkout.shipping-option-item.render-after — Add content after shipping options
• purchase.checkout.payment-method-list.render-before — Add content before payment methods
• purchase.checkout.contact.render-after — Add content after the contact section
• purchase.thank-you.block.render — Add blocks to the thank you page
• purchase.order-status.block.render — Add blocks to the order status page

Common use cases implemented with Checkout UI Extensions:

• Upsell offers (“Add X for just $Y before completing your order”)
• Loyalty point balance display and earn preview
• Custom delivery instructions field
• Gift wrapping options with price
• Warranty or extended protection upsells
• In-store pickup scheduling interface
• Post-purchase survey (on the thank you page)

Shopify Functions for Business Logic

Shopify Functions allow you to customize Shopify’s backend logic (discounts, shipping, and payment method filtering) without custom checkout UI. Functions run on Shopify’s infrastructure as WebAssembly, meaning they’re fast and don’t require maintaining servers.

Available Function APIs in 2026:

• Discount Functions: Create custom discount logic (e.g., tiered discounts, bundle pricing, member-only offers)
• Shipping Customization Functions: Filter, rename, or reorder shipping options based on cart contents, customer tags, or delivery addresses
• Payment Customization Functions: Hide or rename payment methods based on order value, product type, or customer location
• Order Routing Functions: Direct orders to specific fulfillment locations based on custom rules
• Cart Transform Functions: Modify cart line items (useful for bundle expansion, free gift logic)

The Branding API for Visual Checkout Customization

Available to Shopify Plus merchants, the Branding API provides design tokens that control the visual appearance of Shopify’s hosted checkout. This replaces the old approach of injecting custom CSS into checkout.

Customizable design tokens include:

• Primary and secondary brand colors
• Button border-radius (from pill-shaped to sharp corners)
• Font family for headings and body text
• Input field styling
• Spacing and layout density
• Logo display in checkout header
• Background colors and patterns

The Branding API is implemented via the Admin API’s checkoutBrandingUpsert mutation and produces a pixel-perfect checkout that matches your brand without the maintenance burden of custom CSS overrides that could break with Shopify updates.

For merchants wanting end-to-end checkout customization using Checkout UI Extensions and the Branding API, our custom Shopify development team specializes in exactly this type of implementation. We also offer a conversion rate optimization analysis that includes checkout as a primary focus area.

7 Strategies to Maximize Shopify Checkout Conversions in 2026

Strategy 1: Activate Shop Pay

Shop Pay’s one-click checkout for returning buyers delivers a 91% higher conversion rate on mobile than standard checkout. It’s Shopify’s highest-ROI checkout feature and requires zero development to enable—just go to Settings > Payments > Enable Shop Pay.

In 2026, Shop Pay also supports buy now, pay later (BNPL) through Shop Pay Installments, which has been shown to increase average order values by 20–30% for eligible merchants. Enabling BNPL is particularly effective for stores with average order values above $100.

Strategy 2: Set Up a Custom Checkout Domain

A branded checkout domain (checkout.yourdomain.com instead of checkout.myshopify.com) maintains brand consistency and removes a significant source of checkout hesitation. This feature is now available on all Shopify plans at no extra cost. See our dedicated guide to Shopify custom checkout domains for setup instructions.

Strategy 3: Enable Accelerated Checkout Options

Beyond Shop Pay, Shopify supports Google Pay, Apple Pay, PayPal Express, and Amazon Pay as accelerated checkout options. These one-click methods eliminate the most friction-heavy part of checkout (address and payment entry) for customers who already use these services. Enable every accelerated payment option available for your region in Settings > Payments.

Strategy 4: Minimize Required Form Fields

Every unnecessary field adds friction. Review your checkout field requirements:

• Company name: Set to optional (most customers don’t need this)
• Address Line 2: Set to optional or hidden
• Phone number: Only require if essential for your fulfillment/communication
• First name + last name: Cannot be removed, but ensure autocomplete works (it does by default in Shopify)

Research consistently shows that reducing required form fields by two or three elements improves checkout conversion by 5–10%.

Strategy 5: Add Trust Signals at Checkout

The checkout moment is when payment hesitation is highest. Use Checkout UI Extensions to add trust signals visible during the payment step:

• Security badges (SSL, PCI compliance, payment processor logos)
• Money-back guarantee reminder
• Return policy summary (free returns if applicable)
• Estimated delivery date for the customer’s location
• Customer review count or star rating

Strategy 6: Implement Checkout Upsells

Post-payment upsells (shown on the thank-you page via Checkout UI Extensions) are the highest-converting upsell placement in e-commerce—conversion rates of 3–8% are typical, compared to 0.5–1% for pre-checkout upsells. The customer has already committed to buying; a relevant add-on offer with one-click completion captures incremental revenue with minimal friction.

Strategy 7: Optimize for Mobile Checkout

With 60%+ of Shopify traffic now coming from mobile, checkout must be optimized for touch. Key considerations:

• Ensure address autocomplete is enabled (reduces typing on mobile significantly)
• Test button sizes on actual mobile devices (minimum 44×44px touch targets)
• Enable Apple Pay and Google Pay (eliminates manual card entry entirely for most mobile users)
• Review your checkout on 5–6 different device sizes using Shopify’s preview mode

Error Handling in the Cart API

Robust error handling is essential for production Cart API implementations. The Cart API returns errors in two forms:

userErrors: Business logic errors returned in the mutation response (e.g., invalid product ID, out-of-stock item, invalid discount code). These are expected cases your code should handle gracefully:

// Check for user errors in the response if (data.cartCreate.userErrors.length > 0) {   const errors = data.cartCreate.userErrors;   errors.forEach(error => {     console.error(`Field: ${error.field}, Message: ${error.message}`);     // Display user-friendly error to customer   }); } 

GraphQL errors: Protocol-level errors (authentication failures, rate limiting, malformed queries). These appear in the errors array at the top level of the GraphQL response, separate from the data field.

Common error scenarios to handle:

• Variant sold out or unavailable
• Quantity exceeds inventory
• Invalid or expired discount code
• Cart not found (expired session)
• Rate limit exceeded (Shopify Storefront API allows 2 requests/second per app per store)

Cart Persistence and Session Management

Effective cart persistence improves conversion by allowing customers to resume interrupted shopping sessions. Recommended approach:

1. Store the cart ID in localStorage after cartCreate returns successfully
2. On page load, check for an existing cart ID in localStorage
3. If a cart ID exists, query the cart to verify it’s still valid: query { cart(id: "...") { ... } }
4. If the cart is valid, resume with the existing cart; if not (returned null), create a new one
5. Cart IDs persist for 10 days by default; after that, they expire and you must create a new cart

// Cart persistence pattern const CART_ID_KEY = 'shopify_cart_id';  async function getOrCreateCart(storefront) {   const existingCartId = localStorage.getItem(CART_ID_KEY);      if (existingCartId) {     // Verify existing cart is still valid     const existingCart = await storefront.query(CART_QUERY, {       variables: { id: existingCartId }     });          if (existingCart.data.cart) {       return existingCart.data.cart;     }   }      // Create new cart if none exists or existing is invalid   const result = await storefront.mutate(CART_CREATE_MUTATION, {     variables: { input: {} }   });      const newCart = result.data.cartCreate.cart;   localStorage.setItem(CART_ID_KEY, newCart.id);   return newCart; } 

Shopify Checkout API for Mobile Apps: Checkout Sheet Kit

For mobile app developers, Shopify’s Checkout Sheet Kit provides the recommended approach for presenting Shopify checkout within native apps. The SDK is available for:

• iOS/Swift: ShopifyCheckoutSheetKit Swift Package
• Android/Kotlin: Gradle dependency
• React Native: @shopify/checkout-sheet-kit NPM package

The Sheet Kit presents Shopify’s web checkout in a modal sheet that feels native to the platform, supporting:

• Dark and light mode
• Apple Pay and Google Pay native payment sheets
• Shop Pay one-tap completion
• All Checkout UI Extensions
• Privacy consent compliance

For mobile app implementations, the Sheet Kit eliminates the need to build custom checkout UI—a significant engineering and compliance effort. Most mobile-first Shopify brands use the Sheet Kit rather than building their own checkout experience.

When to Use Shopify’s Hosted Checkout vs. Custom Checkout

A common question from merchants and developers: should I customize Shopify’s checkout, or build a completely custom checkout experience?

In 2026, the answer is almost always: customize Shopify’s hosted checkout via Extensions and Functions, don’t build a custom checkout from scratch.

Reasons to stay with Shopify’s hosted checkout:

• Shopify maintains PCI DSS Level 1 compliance (the highest standard). Building your own checkout means maintaining this compliance yourself—a significant legal and technical burden.
• Shop Pay’s 91% mobile conversion advantage is tied to Shopify’s hosted checkout
• Shopify continuously A/B tests and optimizes its checkout—you benefit from their optimization investment
• Checkout UI Extensions let you add significant custom functionality without taking on the infrastructure burden
• Shopify Functions allow custom discount and shipping logic without custom server infrastructure

Cases where custom checkout may be justified:

• Highly specialized B2B ordering workflows (quote-to-order, multi-approval purchase flows)
• Complex subscription models that don’t fit Shopify’s subscription infrastructure
• Regulatory requirements specific to certain industries (e.g., age verification, prescription validation)

For almost all DTC brands, the combination of Shopify’s hosted checkout + Checkout UI Extensions + Shopify Functions covers the required functionality with significantly lower development and compliance cost than a fully custom checkout.

If you’re building a complex checkout customization or migrating from the deprecated Checkout API, our custom Shopify development team handles these implementations regularly. We can also advise on whether your specific use case justifies customization beyond what the Extensions platform supports. If you’re considering the investment, our Shopify expert cost guide provides transparent pricing context.

Frequently Asked Questions: Shopify Checkout API 2026

Is the Shopify Checkout API still available in 2026?

No. The Shopify Checkout API (including Storefront Checkout Mutations and REST Checkout Endpoints) was permanently shut down on April 1, 2025. Any integrations still using the old API stopped functioning on that date. The replacement is the Storefront Cart API—use cartCreate and related mutations to manage cart sessions, then redirect customers to checkout via cart.checkoutUrl.

What is the Storefront Cart API?

The Storefront Cart API is Shopify’s current GraphQL-based API for managing shopping cart sessions in custom storefronts and headless implementations. It handles cart creation, item management (add/update/remove), discount application, buyer identity, and custom attributes. The cart’s checkoutUrl is used to redirect customers to Shopify’s hosted checkout when they’re ready to purchase.

Do I need the Checkout API to create a custom checkout on Shopify?

No—and since the Checkout API was deprecated in 2025, it’s no longer an option. For checkout customization in 2026, use:

• Checkout UI Extensions — for adding custom UI components to Shopify’s hosted checkout
• Shopify Functions — for custom business logic (discounts, shipping, payment methods)
• Branding API — for visual design customization (Shopify Plus only)
• Checkout Sheet Kit — for mobile app checkout integration

What scope do I need for the Storefront Cart API?

The Storefront Cart API is accessible via the Storefront API using a public access token. You don’t need admin API access for cart operations. Ensure your Storefront API app has unauthenticated_write_checkouts scope enabled for cart mutations. For customer-specific features (reading customer account data), additional scopes may be required.

Can I add custom fields to Shopify checkout?

Yes, via two methods:

1. Cart attributes: Pass custom data through the cart to the order using cartAttributesUpdate. These appear on the order but are not displayed to the customer during checkout.
2. Checkout UI Extensions: Render custom form fields in the checkout UI that collect data from the customer. This data can be saved as order attributes and used for order processing logic.

How do I handle the Checkout API migration for an existing app?

If you have an existing app or integration using the old Checkout API, the migration guide from Shopify involves:

1. Replace checkoutCreate with cartCreate
2. Replace all checkout line item mutations with their cartLines* equivalents
3. Replace checkoutDiscountCodeApply with cartDiscountCodesUpdate
4. Replace buyer identity mutations with cartBuyerIdentityUpdate
5. Replace checkout.webUrl with cart.checkoutUrl
6. Replace checkoutUserErrors with userErrors in error handling
7. Test the full flow thoroughly, especially for edge cases (discounts, customer-specific pricing, multi-currency)

If your app used the Checkout REST Admin API (rather than Storefront GraphQL), migration is more complex and may require rearchitecting the integration. Our Shopify experts have handled numerous migrations of this type and can assess the scope of your specific situation.

Next Steps: Building and Optimizing Your Shopify Checkout

Whether you’re implementing the Storefront Cart API for the first time, migrating from the deprecated Checkout API, or looking to maximize conversions from your existing checkout setup, here’s a practical path forward:

For new implementations:

1. Generate your Storefront API access token (Shopify admin > Apps > Develop apps)
2. Implement cartCreate and test the full flow through checkout
3. Add cart persistence via localStorage
4. Enable accelerated checkout options (Shop Pay, Apple Pay, Google Pay)
5. Set up a custom checkout domain

For existing stores focusing on conversion optimization:

1. Run a checkout abandonment audit (Shopify Analytics > Behavior > Checkout)
2. Install Microsoft Clarity and watch 20 checkout session recordings
3. Identify the top three friction points and prioritize fixes
4. Implement Checkout UI Extensions for trust signals and upsell opportunities
5. A/B test checkout changes with statistical rigor

Our conversion rate optimization team specializes in checkout analysis and improvement, consistently delivering 10–25% checkout conversion improvements for Shopify merchants. If you’re ready to take checkout seriously as a revenue lever, reach out to our team for a checkout audit and roadmap.