Shopify Scripts na 30 juni 2026: migreren naar Functions

Op 14 oktober 2026 zijn beide Shopify Scripts-mijlpalen verstreken: bewerken en publiceren stopten op 15 april en Scripts werden vanaf 30 juni niet meer uitgevoerd. Bekijk het Customizations Report van Shopify en identificeer checkoutgedrag dat afhankelijk was van Scripts.

Deze gids legt uit hoe je betrokken aanpassingen beoordeelt en Shopify Functions gebruikt voor ondersteunde korting-, bezorg- en betalingslogica. Scripts verzorgden checkoutgedrag; ze realiseerden geen bestelbewerkingen na aankoop, zoals het wijzigen van een verzendadres nadat een bestelling was geplaatst.

Kort antwoord: van Scripts naar Functions in 60 seconden#

Huidige situatie: Shopify Scripts worden sinds 30 juni 2026 niet meer uitgevoerd. Shopify Functions bieden ondersteunde API’s voor checkoutaanpassingen zoals kortingen, bezorging en betaling. Openbare apps die Functions gebruiken zijn op alle abonnementen beschikbaar; maatwerkapps met Functions vereisen Shopify Plus. Begin met de migratiegids van Shopify en de actuele extensiesjabloon die de CLI genereert en valideer daarna de werking in een ontwikkelwinkel.

Wat er in 2026 is veranderd#

De door Shopify aangekondigde datums zijn verstreken. De Script Editor werd op 15 april alleen-lezen en Scripts worden sinds 30 juni 2026 niet meer uitgevoerd.

Als een winkel op een Script steunde, stopte het gedrag na de einddatum, tenzij het was vervangen of anders was ingesteld. Controleer het daadwerkelijke checkoutgedrag in de winkel; ga er niet van uit dat elke betrokken instelling op dezelfde manier terugvalt.

Tip: Bekijk het Customizations Report in Shopify Admin om aanpassingen te inventariseren die door het einde van Scripts worden geraakt. Gebruik de actuele migratiedocumentatie van Shopify om de vervanging voor elk onderdeel te bevestigen.

Functions versus Scripts: wat is er veranderd?#

De architectuurverandering is belangrijk: Scripts waren Ruby-aanpassingen in de Script Editor; Functions zijn appextensies die met de ondersteunde Shopify-tools worden ontwikkeld. Hun extensietargets en abonnementseisen verschillen, dus gebruik de migratiedocumentatie om elk Script aan een ondersteunde vervanging te koppelen.

Je Scripts koppelen aan het juiste type Function#

Een Script kan overeenkomen met een Function, openbare app, andere ondersteunde instelling of geen vervanging. Gebruik de migratiegids van Shopify om de juiste optie voor elke aanpassing te controleren.

Verschillende Scripts kunnen op één Function uitkomen of afzonderlijke vervangingen vereisen. Bevestig voor elk geval de koppeling en werking voordat je logica combineert.

Voorbereiding: richt je lokale ontwikkelomgeving in#

Voordat je een Function opzet, heb je lokaal drie dingen nodig. Voer deze controles uit in je terminal.

1. Node.js#

Gebruik een Node.js-versie die de huidige Shopify CLI-release ondersteunt; controleer de installatievereisten van de CLI voordat je het project opzet.

node --version
# Check the version required by your installed Shopify CLI

Gebruik je een oudere versie? Installeer Node.js dan via nvm of download het van nodejs.org.

2. Actuele Shopify CLI#

Installeer de actuele Shopify CLI-versie en controleer die met shopify version. Voor de huidige Rust Function-crate (2.0.0 en later) documenteert Shopify CLI 3.85.0 of hoger.

3. Rust-toolchain (alleen als je Functions in Rust schrijft)#

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-unknown-unknown
cargo --version

Voor JavaScript Functions heb je Rust niet nodig. Kies één taal voor je team en houd het daarbij. Beide talen gebruiken zorgt voor meer onderhoudswerk.

4. Een ontwikkelwinkel#

Log in op je Partner-dashboard en maak een nieuwe ontwikkelwinkel aan, of gebruik een bestaande. Je implementeert Functions eerst in deze winkel voordat je ze in productie neemt.

Je eerste Function opzetten#

De CLI maakt het grootste deel van de basisbestanden voor je aan. Voer in een willekeurige map het volgende uit:

# Create a new Shopify app (skip if you already have one)
shopify app init --name my-checkout-functions
cd my-checkout-functions

# Generate a Function extension
shopify app generate extension

De CLI leidt je door een aantal keuzes. Voor een kortingsfunctie kies je:

• Type: Function
• Template: discount (of bijvoorbeeld cart_checkout_validation, delivery_customization of payment_customization)
• Language: Rust of JavaScript
• Name: bijvoorbeeld volume-discount-fn

Hiermee wordt extensions/volume-discount-fn/ aangemaakt:

extensions/volume-discount-fn/
├── shopify.extension.toml      # Function config — targets, build, version
├── src/
│   ├── cart_lines_discounts_generate_run.graphql   # Input query
│   └── cart_lines_discounts_generate_run.rs        # Function logic
├── Cargo.toml                  # Rust dependencies (Rust only)
└── README.md

De drie bestanden die je het vaakst bewerkt, zijn .toml voor de configuratie, .graphql voor de invoer en .rs / .js voor de logica.

Handleiding 1: een Line Item Script vervangen (volumekorting)#

Stel dat je oude Script 10% korting op het subtotaal van de bestelling gaf zodra de winkelwagen 5+ stuks uit een specifieke collectie bevatte. Dit is het equivalent met een Function.

Stap 1.1: de configuratie (shopify.extension.toml)#

api_version = "2026-10"
 
[[extensions]]
name = "volume-discount-fn"
handle = "volume-discount-fn"
type = "function"
  
[[extensions.targeting]]
target = "cart.lines.discounts.generate.run"
input_query = "src/cart_lines_discounts_generate_run.graphql"
export = "cart_lines_discounts_generate_run"
   
[extensions.build]
command = "cargo build --target=wasm32-unknown-unknown --release"
path = "target/wasm32-unknown-unknown/release/volume-discount-fn.wasm"
watch = ["src/**/*.rs"]

Stap 1.2: de invoerquery (src/cart_lines_discounts_generate_run.graphql)#

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        subtotalAmount {
          amount
        }
      }
      merchandise {
        ... on ProductVariant {
          product {
            inAnyCollection(ids: ["gid://shopify/Collection/123456789"])
          }
        } 
      } 
    }
  }
  discount {
    discountClasses
  } 
}

Tip: Functions zien alleen de gegevens die je opvraagt. Houd je GraphQL-query zo klein mogelijk: elk veld dat je weglaat, maakt de uitvoering sneller en goedkoper.

Stap 1.3: de logica (src/cart_lines_discounts_generate_run.rs)#

use super::schema;
use shopify_function::prelude::*;
use shopify_function::Result;
    
#[shopify_function]
fn cart_lines_discounts_generate_run(
    input: schema::cart_lines_discounts_generate_run::Input,
) -> Result<schema::CartLinesDiscountsGenerateRunResult> {
    // Bail if discount class doesn't match
    let has_order_discount = input
        .discount()
        .discount_classes()
        .contains(&schema::DiscountClass::Order);
     
    if !has_order_discount {
        return Ok(schema::CartLinesDiscountsGenerateRunResult { operations: vec![] });
    } 
      
    // Sum quantities of items in the target collection
    let qualifying_qty: i64 = input
        .cart()
        .lines()
        .iter()
        .filter(|line| {
            if let schema::Merchandise::ProductVariant(v) = line.merchandise() {
                *v.product().in_any_collection()
            } else {
                false
            }
        })
        .map(|line| *line.quantity())
        .sum();
       
    if qualifying_qty < 5 {
        return Ok(schema::CartLinesDiscountsGenerateRunResult { operations: vec![] }); 
    }  
        
    // Apply 10% off the order subtotal
    Ok(schema::CartLinesDiscountsGenerateRunResult {
        operations: vec![schema::CartOperation::OrderDiscountsAdd(
            schema::OrderDiscountsAddOperation {
                selection_strategy: schema::OrderDiscountSelectionStrategy::First,
                candidates: vec![schema::OrderDiscountCandidate {
                    targets: vec![schema::OrderDiscountCandidateTarget::OrderSubtotal(
                        schema::OrderSubtotalTarget {
                            excluded_cart_line_ids: vec![],
                        },
                    )],
                    message: Some("Volume discount: 10% off".to_string()),
                    value: schema::OrderDiscountCandidateValue::Percentage(
                        schema::Percentage { value: Decimal(10.0) }
                    ),
                    conditions: None,
                    associated_discount_code: None,
                }],
            },
        )],
    })
} 

Stap 1.4: testen, implementeren en activeren#

# Local development with hot reload
shopify app dev
         
# When ready, deploy
shopify app deploy
          
# In the GraphiQL panel that opens (press `g` in the dev terminal),
# create the automatic discount that uses your Function:

mutation CreateAutomaticDiscount($startsAt: DateTime!) {
  discountAutomaticAppCreate(
    automaticAppDiscount: {
      title: "Volume Discount (5+ collection items)"
      functionHandle: "volume-discount-fn"
      discountClasses: [ORDER]
      startsAt: $startsAt
    }   
  ) {
    automaticAppDiscount { discountId }
    userErrors { field message }
  }  
}  

Stel in het paneel Query Variables van GraphiQL startsAt in op een toekomstig ISO 8601-tijdstempel. Controleer eventuele aanvullende verplichte velden voor je API-versie voordat je de mutatie uitvoert.

Dit maakt de automatische korting die de uitgerolde Function aanroept; de Function vervangt de Script-logica voor dit gebruiksscenario.

Handleiding 2: een Shipping Script vervangen (verzendmethode verbergen boven een drempel)#

Een veelvoorkomend Script is: ‘Verberg Express Shipping als het subtotaal van de winkelwagen hoger is dan $500, zodat grote bestellingen geen dure nachtelijke verzending krijgen.’ Dit is de versie met een Delivery Customization Function.

Handleidingen 2 en 3 gebruiken de huidige JavaScript-sjablonen. Behoud de gegenereerde targets en exports in src/index.js, stel api_version = "2026-10" in het bestand shopify.extension.toml van elke extensie in en voer na het vervangen van de invoerquery shopify app function typegen uit in de map van elke extensie.

Stap 2.1: de basisbestanden aanmaken#

shopify app generate extension --template delivery_customization --flavor vanilla-js --name hide-express-fn

Stap 2.2: invoerquery (src/cart_delivery_options_transform_run.graphql)#

query CartDeliveryOptionsTransformRunInput { 
  cart { 
    cost {
      subtotalAmount {
        amount
      }  
    }    
    deliveryGroups {
      deliveryOptions {
        handle
        title
      }   
    }     
  }   
}   

Stap 2.3: logica (src/cart_delivery_options_transform_run.js)#

// @ts-check
/**
 * @typedef {import("../generated/api").CartDeliveryOptionsTransformRunInput} CartDeliveryOptionsTransformRunInput
 * @typedef {import("../generated/api").CartDeliveryOptionsTransformRunResult} CartDeliveryOptionsTransformRunResult
 */
           
/** @type {CartDeliveryOptionsTransformRunResult} */
const NO_CHANGES = { operations: [] };
const THRESHOLD = 500.0;
const HIDE_TITLES = ["Express", "Overnight"];
            
/** 
 * @param {CartDeliveryOptionsTransformRunInput} input
 * @returns {CartDeliveryOptionsTransformRunResult}
 */ 
export function cartDeliveryOptionsTransformRun(input) {
  const subtotal = parseFloat(input.cart.cost.subtotalAmount.amount);
  if (subtotal < THRESHOLD) return NO_CHANGES;
             
  const operations = input.cart.deliveryGroups.flatMap((group) =>
    group.deliveryOptions
      .filter((opt) => HIDE_TITLES.some((t) => (opt.title ?? "").includes(t)))
      .map((opt) => ({
        deliveryOptionHide: { deliveryOptionHandle: opt.handle },
      }))
  );
              
  return { operations };
}    

Stap 2.4: de bezorgaanpassing maken en activeren#

Voer na shopify app deploy en installatie van de app in de doelwinkel deliveryCustomizationCreate uit via de geauthenticeerde Admin GraphQL-client van die app met de scope write_delivery_customizations. Stel de variabele functionHandle in op de handle van de extensie in shopify.extension.toml (bijvoorbeeld hide-express-fn).

mutation CreateDeliveryCustomization($functionHandle: String!) {
  deliveryCustomizationCreate(deliveryCustomization: {
    functionHandle: $functionHandle
    title: "Hide express shipping above cart threshold"
    enabled: true
  }) {
    deliveryCustomization { id enabled }
    userErrors { field message }
  }
}

Controleer of het antwoord een ingeschakelde aanpassing en geen userErrors bevat. Controleer vervolgens Instellingen → Verzending en bezorging → Bezorgaanpassingen en test het checkoutgedrag. De uitrol levert de Function; deze mutatie maakt en activeert de aanpassing voor de winkel.

Handleiding 3: een Payment Script vervangen (rembours verbergen voor B2B)#

Het oude Script: ‘Verberg betalen bij levering voor elke klant met de tag “B2B”.’ Dit is de versie met Payment Customization.

Stap 3.1: de basisbestanden aanmaken#

shopify app generate extension --template payment_customization --flavor vanilla-js --name hide-cod-b2b-fn

Stap 3.2: invoerquery (src/cart_payment_methods_transform_run.graphql)#

query CartPaymentMethodsTransformRunInput {  
  cart {  
    buyerIdentity {
      customer {
        hasTags(tags: ["B2B"]) {
          tag
          hasTag
        }  
      }    
    }      
  }    
  paymentMethods {
    id
    name
  }     
}     

Stap 3.3: logica (src/cart_payment_methods_transform_run.js)#

// @ts-check
/**
 * @typedef {import("../generated/api").CartPaymentMethodsTransformRunInput} CartPaymentMethodsTransformRunInput
 * @typedef {import("../generated/api").CartPaymentMethodsTransformRunResult} CartPaymentMethodsTransformRunResult
 */
/** @type {CartPaymentMethodsTransformRunResult} */
const NO_CHANGES = { operations: [] }; 
               
/**
 * @param {CartPaymentMethodsTransformRunInput} input
 * @returns {CartPaymentMethodsTransformRunResult}
 */
export function cartPaymentMethodsTransformRun(input) { 
  const tagCheck = input.cart?.buyerIdentity?.customer?.hasTags?.[0];
  const isB2B = tagCheck?.hasTag === true;
  if (!isB2B) return NO_CHANGES;
                
  const codMethod = input.paymentMethods.find((pm) =>
    pm.name.toLowerCase().includes("cash on delivery")
  ); 
  if (!codMethod) return NO_CHANGES;
                 
  return {
    operations: [{ paymentMethodHide: { paymentMethodId: codMethod.id } }],
  };
}      

Stap 3.4: de betalingsaanpassing maken en activeren#

Voer na de uitrol en installatie van de app in de doelwinkel paymentCustomizationCreate uit via de geauthenticeerde Admin GraphQL-client van die app met de scope write_payment_customizations. Stel functionHandle in op de handle van de betalingsextensie in shopify.extension.toml (bijvoorbeeld hide-cod-b2b-fn).

mutation CreatePaymentCustomization($functionHandle: String!) {
  paymentCustomizationCreate(paymentCustomization: {
    functionHandle: $functionHandle
    title: "Hide Cash on Delivery for B2B-tagged customers"
    enabled: true
  }) {
    paymentCustomization { id enabled }
    userErrors { field message }
  }
}

Controleer of het antwoord een ingeschakelde betalingsaanpassing en geen userErrors bevat. Controleer deze onder Instellingen → Betalingen → Betalingsaanpassingen en test vervolgens de checkout met klanten met en zonder de B2B-tag.

Nu je hier toch bent — een opmerking over wijzigingen na aankoop#

Voor wijzigingen na checkout biedt Revize geschikte klantselfservice vóór de orderafhandeling via de bestelstatuspagina of een bevestigingsmaillink binnen de ingestelde bewerkingsperiode. Producten omruilen en toevoegen vereisen Pro; bewerken door medewerkers is in ontwikkeling. Klanten controleren een extra saldo en betalen via Shopify-checkout. Onze Shopify-orderbeheergids 2026: draaiboek voor Plus-teams behandelt de standaardworkflow van Shopify na checkout.

Terug naar de migratie.

Testaanpak: werken met een klanttag#

Gebruik een ontwikkelwinkel en representatieve invoerfixtures om de vervanger te testen tegen je vastgelegde eisen of opgeslagen Script-testresultaten. Scripts worden niet meer uitgevoerd, dus een live paralleltest met Script en Function is niet meer mogelijk. Een klanttagvoorwaarde kan een test-Function tot interne accounts beperken terwijl je het gedrag controleert; houd productie-uitrol apart van deze tests.

Stap 1: geef je testgebruikers een tag#

Voeg in Customers de tag FN-TESTER toe aan twee of drie interne klantaccounts.

Stap 2: laat de Function controleren op die tag#

// Rust example: return this target's empty result for non-testers
let is_tester = input
    .cart()
    .buyer_identity()
    .and_then(|bi| bi.customer())
    .map(|c| c.has_any_tag())
    .unwrap_or(&false);
                  
if !*is_tester {
    return Ok(default_result);  // No operations from this Function
}       
                   
// New Function logic only runs for tagged users

Stap 3: voeg hasAnyTag toe aan je invoerquery#

cart {
  buyerIdentity {
    customer {
      hasAnyTag(tags: ["FN-TESTER"])
    }       
  }      
}        

Stap 4: controleer het gedrag in de checkout#

Log in met een getagde gebruiker en controleer geschikte en ongeschikte winkelwagens, kortingscombinaties en bezorg- en betaalopties. Herhaal dit met een ongetagde gebruiker om te bevestigen dat deze Function geen bewerkingen teruggeeft. Vergelijk de resultaten met het verwachte gedrag dat uit de oude logica is vastgelegd; neem gastcheckout in je tests op voordat je de tagvoorwaarde verwijdert.

Stap 5: controleer de productieactivering#

Activeer de geteste vervanger via de juiste kortings-, bezorg- of betalingsconfiguratie. Leg de uitgerolde appversie en het terugdraaiplan vast en verwijder daarna verouderde Script-instructies uit de teamdocumentatie.

Een implementatieproces dat kan meegroeien#

Blijf niet voor altijd implementeren vanaf de laptop van een ontwikkelaar. Zodra je een of twee Scripts hebt gemigreerd, richt je een CI-pijplijn in.

Een eenvoudige werkende opzet#

# .github/workflows/deploy-functions.yml
name: Deploy Shopify Functions
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '22' }
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: wasm32-unknown-unknown }
      - run: npm install -g @shopify/cli@latest
      - run: shopify app deploy --force
        env:
          SHOPIFY_APP_AUTOMATION_TOKEN: ${{ secrets.SHOPIFY_APP_AUTOMATION_TOKEN }}

Maak een App Automation Token in het Dev Dashboard van Shopify en sla dit op als het hierboven getoonde repositorysecret. De huidige CLI vereist Node.js 22.12 of nieuwer. Koppel het project aan zijn appconfiguratie vóór gebruik van CI; voeg vóór implementatie je tests en releasecontroles toe. Dit voorbeeld implementeert bij een push naar main; pas de trigger daarom aan het releasebeleid van je team aan.

Versiebeheer en terugdraaien#

shopify app deploy maakt een momentopname met een versienummer. Zo ga je terug naar een eerdere versie:

shopify app versions list
shopify app release --version <previous-version-id>

Bij Scripts moest je de oude code terugvinden en opnieuw plakken om een wijziging terug te draaien. Dit is een stuk eenvoudiger.

Wat de meeste teams verkeerd doen#

Dit zijn veelvoorkomende migratievalkuilen om vóór het uitbrengen van een Function te controleren.

1. Functions behandelen als een één-op-éénkopie van Scripts. Eén Function kan drie Scripts vervangen met duidelijkere voorwaarden. Bekijk eerst hoe je Scripts samen werken voordat je ze herschrijft.

2. App-scopes verwarren met Function-invoergegevens. Een Function leest de velden die de invoerquery en ingestelde metavelden beschikbaar stellen; read_customers of read_orders toevoegen geeft geen Admin API-toegang. Voeg app-scopes alleen voor afzonderlijke Admin API-bewerkingen toe en controleer de invoer- en configuratieregels van de Function API voor de extensie die je bouwt.

3. Gelijkwaardigheidstests overslaan. Vergelijk de Function vóór uitrol met het oude Script met representatieve winkelwagens en relevante randgevallen. Gebruik alleen een gefaseerde uitrol als je extensie en configuratie die ondersteunen.

4. Het Customizations Report overslaan. Dit rapport geeft je het beste overzicht van wat er werkelijk draait. Baseer je migratie op het rapport, niet op je geheugen.

5. Collectie-ID’s en klanttags rechtstreeks in de code zetten. Gebruik Function-configuratie via metafields als verkopers de waarden moeten kunnen aanpassen. De CLI kan configuratie op basis van metafields voor je opzetten. Bekijk hiervoor de Shopify-documentatie over Function-configuratie.

Migratiechecklist#

Gebruik deze checklist om de actuele staat van een Scripts-migratie te beoordelen.

Omdat de uitvoeringsdeadline is verstreken, geef je prioriteit aan controle van het actieve checkoutgedrag en eventueel resterend vervangingswerk.

Volgende stappen#

1. Bekijk het Customizations Report en de actuele migratiegids van Shopify.
2. Test de betreffende checkoutsituaties in een ontwikkelwinkel.
3. Bevestig welke Functions of openbare apps de vereiste logica op je abonnement ondersteunen.
4. Controleer elke productievervanger en leg de verantwoordelijke en configuratie vast.

Houd checkoutregeltests apart van tests voor bestelbewerking na aankoop. Leg per systeem de verantwoordelijke app, ingeschakelde functies en het afhandelings- en betalingsgedrag vast, zodat toekomstige wijzigingen een duidelijke eigenaar hebben.

Bronnen#

• Overzicht van Shopify Functions — Shopify Developer Docs
• Migreren van Shopify Scripts naar Functions
• Handleiding voor het bouwen van een kortings-Function
• API-documentatie voor Delivery Customization Functions
• API-documentatie voor Payment Customization Functions
• Documentatie voor Shopify CLI

Verder lezen: Statistieken over Shopify-bestellingen bewerken (2026) · Klanten hun eigen bestellingen laten bewerken in Shopify (2026)