Shopify Scripts to Functions Migration: Complete Guide (June 2026 Deadline)

Shopify announced in Winter '26 Edition that Scripts will be fully deprecated by June 2026. If your store uses Script-based checkout customizations — discounts, shipping logic, payment filters — you need to migrate to Shopify Functions. This guide walks you through everything: what's changing, why it matters, and exactly how to migrate.

TL;DR

• Shopify Scripts deprecated — must migrate to Functions by June 2026
• Functions execute faster and have better parity with Shopify's backend
• Migration is not automatic — requires code rewrite from Ruby to JavaScript/TypeScript
• New API capabilities in Functions that Scripts couldn't access
• Start now — June deadline is closer than it looks

The Deadline: June 2026

Shopify announced in Winter '26 Edition that Scripts will be fully deprecated by June 2026. After that date, Script-based checkout customizations will stop working.

Why the change?

• Scripts run on Shopify's legacy infrastructure
• Functions run on WebAssembly — faster, sandboxed, more secure
• Better integration with Shopify's modern checkout platform
• AI-ready infrastructure for future commerce features

Scripts vs Functions: Key Differences

• Language: Scripts use Ruby (deprecated); Functions use JavaScript/TypeScript
• Runtime: Scripts ran on Shopify's legacy infra; Functions run on WebAssembly (Wasm)
• Execution speed: Scripts were server-side (slower); Functions are edge-executed (sub-5ms)
• Scope: Scripts handled line items, shipping, payments; Functions cover broader: discounts, delivery, payment customizations
• API Access: Scripts had limited API access; Functions have full GraphQL Admin API access
• AI Integration: Scripts had none; Functions are Sidekick-ready and agent-compatible

Migration Strategy

Step 1: Inventory Your Scripts

Find all Scripts in your store using Shopify CLI:

# Using Shopify CLI
shopify script list --store=your-store.myshopify.com

Or check in admin: Settings → Checkout → Scripts

Document for each Script:

• Script type (line items, shipping, payments)
• Current logic and business rules
• Dependencies on other apps or metafields

Step 2: Choose Function Type

Shopify Functions now cover:

• Product discounts — cart-level and automatic
• Order discounts — percentage/fixed amount
• Shipping discounts — free shipping, rate modifications
• Payment customizations — hide/show methods, reorder
• Delivery customizations — delivery options at checkout

Step 3: Rewrite Logic

Before (Ruby Script):

# Line item script example
class ScriptRunner
  def run(input)
    input.cart.line_items.each do |line_item|
      if line_item.variant.product.tags.include?('BULK')
        line_item.change_line_price(
          line_item.line_price * 0.9,
          message: 'Bulk discount'
        )
      end
    end
  end
end

After (JavaScript Function):

// Shopify Function
import {
  ProductDiscountFunction,
  ProductDiscountInput,
  ProductDiscountOutput,
} from '@shopify/shopify_function';

export function run(input: ProductDiscountInput): ProductDiscountOutput {
  const targets = input.cart.lines
    .filter(line => line.merchandise.product.tags.includes('BULK'))
    .map(line => ({
      productVariant: line.merchandise.id,
      quantity: line.quantity,
    }));

  return {
    discounts: [{
      targets,
      value: {
        percentage: { value: 10 }, // 10% off
      },
      message: 'Bulk discount',
    }],
    discountApplicationStrategy: 'FIRST',
  };
}

Key changes in the migration:

• Ruby → TypeScript
• Direct mutation → Return output object
• Tag-based logic remains similar
• Function input/output strictly typed

Step 4: Test Locally

Shopify CLI now supports local Function testing:

# Create new Function app
shopify app create --template=discount_function

# Local development server
shopify app dev

# Run unit tests
npm test

Step 5: Deploy & Monitor

# Deploy to Shopify
shopify function push

# Monitor in Shopify Admin
# Apps → [Your App] → Functions

Common Migration Challenges

1. Metafield Access

Scripts could read product/customer metafields directly. Functions require GraphQL input queries.

Solution: Define input query in input.graphql:

query Input {
  cart {
    lines {
      merchandise {
        ... on ProductVariant {
          metafield(namespace: "custom", key: "tier") {
            value
          }
        }
      }
    }
  }
}

2. External API Calls

Scripts couldn't make external API calls. Functions still can't (WebAssembly sandbox).

Solution: Use Shopify Flow + your app backend for external data, then pass to Function via metafields.

3. Complex Logic

Some Script logic doesn't map 1:1 to Function discount types.

Solution: Combine multiple Functions or use Payment/Delivery customizations for non-discount logic.

Timeline Recommendation

• March 2026: Inventory all Scripts, prioritize critical ones
• April 2026: Migrate high-priority Scripts to Functions
• May 2026: Migrate remaining Scripts, full testing
• Early June: Final deployment, monitor for issues
• June 2026: Scripts deprecated — must be on Functions

FAQ

Do I have to migrate?

Yes. Scripts will stop working after June 2026. No grandfathering.

Can I run both Scripts and Functions?

Temporarily. Test Functions alongside Scripts, then disable Scripts once verified.

Will my discounts look different to customers?

Should look identical. Functions have the same presentation layer in checkout.

What about Shopify Plus stores?

Same deadline applies. No exceptions for Shopify Plus.

Is there a migration tool?

Not automatic. Shopify provides templates and CLI scaffolding, but logic must be rewritten.

Bottom Line

Migration is mandatory, not optional. The good news: Functions are more powerful, faster, and future-proof. The bad news: you have 3 months left.

Start with your most critical discount Script. Get one migration under your belt before tackling the rest.

Want help? I migrate Shopify Scripts to Functions — get in touch via the contact page.