Shopify Scripts seit dem 30. Juni 2026: Migration zu Functions

Stand 14. Oktober 2026 sind beide Meilensteine für Shopify Scripts bereits verstrichen: Bearbeiten und Veröffentlichen endeten am 15. April, die Ausführung von Scripts am 30. Juni. Prüfen Sie Shopifys Customizations Report und ermitteln Sie alle Checkout-Abläufe, die von Scripts abhängig waren.

Dieser Leitfaden erklärt, wie Sie betroffene Anpassungen bewerten und Shopify Functions für unterstützte Rabatt-, Versand- und Zahlungslogik einsetzen. Scripts steuerten das Checkout-Verhalten; sie ermöglichten keine Bestelländerungen nach dem Kauf, etwa eine Änderung der Lieferadresse nach Aufgabe einer Bestellung.

Kurzantwort: Von Scripts zu Functions in 60 Sekunden#

Aktueller Stand: Shopify Scripts werden seit dem 30. Juni 2026 nicht mehr ausgeführt. Shopify Functions bieten unterstützte APIs für Checkout-Anpassungen wie Rabatte, Versand und Zahlungen. Öffentliche Apps, die Functions nutzen, sind tarifübergreifend verfügbar; benutzerdefinierte Apps mit Functions erfordern Shopify Plus. Beginnen Sie mit Shopifys Migrationsleitfaden und der aktuellen, von der CLI erzeugten Erweiterungsvorlage und prüfen Sie das Verhalten anschließend in einem Entwicklungs-Shop.

Was sich 2026 geändert hat#

Die von Shopify angekündigten Termine sind verstrichen. Der Script Editor ist seit dem 15. April schreibgeschützt, und Scripts werden seit dem 30. Juni 2026 nicht mehr ausgeführt.

Wenn ein Shop von einem Script abhängig war, wurde dessen Logik nach dem Stichtag nicht mehr ausgeführt, sofern sie nicht ersetzt oder anderweitig neu konfiguriert worden war. Prüfen Sie das tatsächliche Checkout-Verhalten im Shop; gehen Sie nicht davon aus, dass jede betroffene Einstellung auf dieselbe Weise auf einen Standard zurückfällt.

Tipp: Prüfen Sie den Customizations Report im Shopify-Adminbereich, um die von der Scripts-Abschaltung betroffenen Anpassungen zu erfassen. Bestätigen Sie anhand der aktuellen Migrationsdokumentation von Shopify den Ersatz für jede einzelne Anpassung.

Functions und Scripts: Was sich tatsächlich geändert hat#

Der Architekturwechsel ist entscheidend: Scripts waren Ruby-Anpassungen im Script Editor; Functions sind App-Erweiterungen, die mit Shopifys unterstützten Werkzeugen entwickelt werden. Ihre Erweiterungs-Targets und Tarifanforderungen unterscheiden sich. Ordnen Sie daher jedes Script mithilfe der Migrationsdokumentation einem unterstützten Ersatz zu.

So ordnen Sie Ihre Scripts dem richtigen Function-Typ zu#

Ein Script lässt sich möglicherweise durch eine Function, eine öffentliche App oder eine andere unterstützte Einstellung ersetzen — oder es gibt keinen Ersatz. Prüfen Sie anhand von Shopifys Migrationsleitfaden die passende Option für jede Anpassung.

Mehrere Scripts können einer einzigen Function entsprechen oder getrennte Ersatzlösungen erfordern. Bestätigen Sie die Zuordnung und das Verhalten in jedem Fall, bevor Sie Logik zusammenführen.

Voraussetzung: Lokale Entwicklungsumgebung einrichten#

Bevor Sie eine Function erstellen, müssen drei Dinge lokal installiert sein. Prüfen Sie sie im Terminal.

1. Node.js#

Verwenden Sie eine Node.js-Version, die von der aktuellen Shopify-CLI-Version unterstützt wird; prüfen Sie vor dem Einrichten des Projekts die Installationsanforderungen der CLI.

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

Falls Ihre Version älter ist, installieren Sie Node.js über nvm oder laden Sie es von nodejs.org herunter.

2. Aktuelle Shopify CLI#

Installieren Sie die aktuelle Shopify CLI und prüfen Sie die Version mit shopify version. Für das aktuelle Rust-Function-Crate (2.0.0 und neuer) nennt Shopify CLI 3.85.0 oder höher.

3. Rust-Toolchain (nur wenn Sie Functions in Rust schreiben)#

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

Für JavaScript-Functions brauchen Sie kein Rust. Wählen Sie für Ihr Team eine Sprache und bleiben Sie dabei. Zwei Sprachen erhöhen den Wartungsaufwand.

4. Ein Entwicklungs-Shop#

Melden Sie sich in Ihrem Partner-Dashboard an und erstellen Sie einen neuen Entwicklungsshop, oder verwenden Sie einen vorhandenen. Sie stellen die Functions zuerst dort bereit und bringen sie anschließend in Produktion.

Ihre erste Function erstellen#

Die CLI übernimmt den Großteil des Grundgerüsts. Führen Sie in einem beliebigen Verzeichnis Folgendes aus:

# 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

Die CLI führt Sie durch die Auswahl. Für eine Rabatt-Function wählen Sie:

• Typ: Function
• Vorlage: discount (oder cart_checkout_validation, delivery_customization, payment_customization usw.)
• Sprache: Rust oder JavaScript
• Name: beispielsweise volume-discount-fn

Dadurch entsteht extensions/volume-discount-fn/ mit folgender Struktur:

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

Sie werden hauptsächlich drei Dateien bearbeiten: .toml für die Konfiguration, .graphql für die Eingabedaten und .rs / .js für die Logik.

Anleitung 1: Line Item Script ersetzen (Mengenrabatt)#

Angenommen, Ihr bisheriges Script gewährt 10 % Rabatt auf die Zwischensumme der Bestellung, sobald der Warenkorb mindestens 5 Artikel aus einer bestimmten Kollektion enthält. So setzen Sie das als Function um.

Schritt 1.1: Konfiguration (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"]

Schritt 1.2: Eingabeabfrage (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
  } 
}

Tipp: Functions sehen nur die Daten, die Sie abfragen. Halten Sie die GraphQL-Abfrage so knapp wie möglich. Jedes weggelassene Feld macht die Ausführung schneller und günstiger.

Schritt 1.3: Logik (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,
                }],
            },
        )],
    })
} 

Schritt 1.4: Testen, bereitstellen, aktivieren#

# 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 }
  }  
}  

Setzen Sie im Bereich Query Variables von GraphiQL startsAt auf einen zukünftigen ISO-8601-Zeitstempel. Prüfen Sie vor dem Ausführen der Mutation alle zusätzlichen Pflichtfelder für Ihre API-Version.

Damit wird der automatische Rabatt erstellt, der die bereitgestellte Function aufruft; die Function ersetzt die Script-Logik für diesen Anwendungsfall.

Anleitung 2: Shipping Script ersetzen (Versandart ab einem Warenkorbwert ausblenden)#

Ein häufiges Script lautet: „Expressversand ausblenden, wenn die Zwischensumme des Warenkorbs über $500 liegt, damit für große Bestellungen keine teure Zustellung über Nacht angeboten wird.“ So sieht die Umsetzung mit einer Delivery Customization Function aus.

Anleitungen 2 und 3 verwenden die aktuellen JavaScript-Vorlagen. Behalten Sie die generierten Targets und die Exporte in src/index.js bei, setzen Sie api_version = "2026-10" in der shopify.extension.toml jeder Erweiterung und führen Sie nach dem Ersetzen der Eingabeabfrage shopify app function typegen im Verzeichnis der jeweiligen Erweiterung aus.

Schritt 2.1: Grundgerüst erstellen#

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

Schritt 2.2: Eingabeabfrage (src/cart_delivery_options_transform_run.graphql)#

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

Schritt 2.3: Logik (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 };
}    

Schritt 2.4: Versandanpassung erstellen und aktivieren#

Führen Sie nach shopify app deploy und der Installation der App im Zielshop deliveryCustomizationCreate über den authentifizierten Admin-GraphQL-Client dieser App mit dem Scope write_delivery_customizations aus. Setzen Sie die Variable functionHandle auf den handle der Erweiterung in shopify.extension.toml (zum Beispiel 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 }
  }
}

Prüfen Sie, ob die Antwort eine aktivierte Anpassung und keine userErrors zurückgibt. Kontrollieren Sie anschließend Einstellungen → Versand und Zustellung → Versandanpassungen und testen Sie das Checkout-Verhalten. Die Bereitstellung liefert die Function; diese Mutation erstellt und aktiviert die Anpassung des Shops.

Anleitung 3: Payment Script ersetzen (Nachnahme für B2B ausblenden)#

Bisheriges Script: „Nachnahme für alle Kunden mit dem Tag ‚B2B‘ ausblenden.“ So setzen Sie es mit Payment Customization um.

Schritt 3.1: Grundgerüst erstellen#

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

Schritt 3.2: Eingabeabfrage (src/cart_payment_methods_transform_run.graphql)#

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

Schritt 3.3: Logik (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 } }],
  };
}      

Schritt 3.4: Zahlungsanpassung erstellen und aktivieren#

Führen Sie nach der Bereitstellung und Installation der App im Zielshop paymentCustomizationCreate über den authentifizierten Admin-GraphQL-Client dieser App mit dem Scope write_payment_customizations aus. Setzen Sie functionHandle auf den handle der Zahlungserweiterung in shopify.extension.toml (zum Beispiel 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 }
  }
}

Prüfen Sie, ob die Antwort eine aktivierte Zahlungsanpassung ohne userErrors enthält. Kontrollieren Sie diese unter Einstellungen → Zahlungen → Zahlungsanpassungen und testen Sie anschließend den Checkout mit Kunden mit und ohne B2B-Tag.

Ein Wort zu Änderungen nach dem Kauf#

Für Änderungen nach dem Checkout bietet Revize berechtigte Kundenselbstbedienung vor dem Fulfillment über die Bestellstatusseite oder einen Bestätigungs-E-Mail-Link während des vom Händler festgelegten Bearbeitungszeitfensters. Produktwechsel und Zusatzprodukte erfordern Pro; die Bearbeitung durch Mitarbeitende ist in Entwicklung. Kunden prüfen zusätzlich fällige Beträge und bezahlen über Shopify Checkout. Der Shopify-Bestellverwaltungsleitfaden 2026 für Plus-Betreiber behandelt Shopifys nativen Ablauf nach dem Checkout.

Zurück zur Migration.

Teststrategie: Kunden mit Tags schrittweise einbeziehen#

Nutzen Sie einen Entwicklungs-Shop und repräsentative Eingabetestdaten, um den Ersatz gegen dokumentierte Anforderungen oder gespeicherte Script-Testergebnisse zu prüfen. Scripts werden nicht mehr ausgeführt, daher ist ein paralleler Live-Test von Script und Function nicht mehr möglich. Eine Kundentag-Prüfung kann eine Test-Function auf interne Konten begrenzen, während Sie ihr Verhalten prüfen; halten Sie die Produktiveinführung von diesen Tests getrennt.

Schritt 1: Testkunden markieren#

Fügen Sie unter Kunden bei zwei oder drei internen Konten den Tag FN-TESTER hinzu.

Schritt 2: Die Function anhand des Tags verzweigen lassen#

// 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

Schritt 3: hasAnyTag zur Eingabeabfrage hinzufügen#

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

Schritt 4: Im Checkout prüfen#

Melden Sie sich als markierter Nutzer an und prüfen Sie berechtigte und unberechtigte Warenkörbe, Rabattkombinationen sowie Liefer- und Zahlungsoptionen. Wiederholen Sie dies mit einem nicht markierten Nutzer, um sicherzustellen, dass diese Function keine Operationen zurückgibt. Vergleichen Sie die Ergebnisse mit dem aus der alten Logik festgehaltenen Sollverhalten; beziehen Sie Gast-Checkouts in die Tests ein, bevor Sie die Tag-Prüfung entfernen.

Schritt 5: Produktivaktivierung prüfen#

Aktivieren Sie den getesteten Ersatz über die passende Rabatt-, Liefer- oder Zahlungskonfiguration. Dokumentieren Sie bereitgestellte App-Version und Rücknahmeplan und entfernen Sie veraltete Script-Anweisungen aus Ihrer Teamdokumentation.

Ein Bereitstellungsablauf, der mit Ihrem Team wächst#

Stellen Sie Functions nicht dauerhaft vom Laptop eines Entwicklers bereit. Sobald Sie ein oder zwei Scripts migriert haben, richten Sie eine CI-Pipeline ein.

Der kleinste sinnvolle Ablauf#

# .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 }}

Erstellen Sie ein App Automation Token im Shopify Dev Dashboard und speichern Sie es als oben gezeigtes Repository-Secret. Die aktuelle CLI erfordert Node.js 22.12 oder neuer. Verknüpfen Sie das Projekt vor der CI-Nutzung mit seiner App-Konfiguration; ergänzen Sie vor der Bereitstellung Test- und Freigabeprüfschritte. Dieses Beispiel stellt bei einem Push auf main bereit. Passen Sie den Auslöser deshalb an die Veröffentlichungsrichtlinie Ihres Teams an.

Versionierung und Zurücksetzen#

shopify app deploy erstellt einen versionierten Stand. So kehren Sie zu einer früheren Version zurück:

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

Bei Scripts mussten Sie für eine Rückkehr den alten Code wiederfinden und erneut einfügen. Hier reicht die vorherige Version.

Fünf häufige Fehler#

Dies sind häufige Migrationsfehler, die Sie vor der Veröffentlichung einer Function prüfen sollten.

1. Functions wie eine 1:1-Portierung von Scripts behandeln. Das sind sie nicht. Eine einzige Function kann drei Scripts mit übersichtlicheren Verzweigungen ersetzen. Prüfen Sie Ihre Scripts als Gesamtsystem, bevor Sie sie neu schreiben.

2. App-Berechtigungen mit Function-Eingabedaten verwechseln. Eine Function liest die Felder, die ihre Eingabeabfrage und die konfigurierten Metafelder bereitstellen; durch Hinzufügen von read_customers oder read_orders erhält sie keinen Admin-API-Zugriff. Ergänzen Sie App-Berechtigungen nur für separate Admin-API-Vorgänge und prüfen Sie die Eingabe- und Konfigurationsregeln der Function API für die Erweiterung, die Sie entwickeln.

3. Tests auf funktionale Gleichwertigkeit auslassen. Vergleichen Sie die Function vor der Veröffentlichung anhand repräsentativer Warenkörbe und relevanter Grenzfälle mit dem alten Script. Nutzen Sie eine schrittweise Einführung nur, wenn Ihre Erweiterung und Konfiguration dies unterstützen.

4. Den Customizations Report überspringen. Er bietet den besten Überblick darüber, was in Ihrem Shop tatsächlich läuft. Migrieren Sie anhand des Berichts, nicht aus dem Gedächtnis.

5. Kollektions-IDs und Kundentags fest im Code hinterlegen. Verwenden Sie die Function-Konfiguration über Metafelder, wenn Händler Werte selbst anpassen sollen. Die CLI kann eine Konfiguration auf Basis von Metafeldern erstellen. Weitere Informationen finden Sie in der Shopify-Dokumentation zur Function-Konfiguration.

Migrationscheckliste#

Prüfen Sie mit dieser Checkliste den aktuellen Stand einer Scripts-Migration.

Da der Stichtag für das Ende der Ausführung bereits verstrichen ist, haben die Prüfung des produktiven Checkout-Verhaltens und noch ausstehende Ersatzlösungen Vorrang.

Nächste Schritte#

1. Prüfen Sie den Customizations Report und Shopifys aktuellen Migrationsleitfaden.
2. Testen Sie die relevanten Checkout-Fälle in einem Entwicklungs-Shop.
3. Bestätigen Sie, welche Functions oder öffentlichen Apps die benötigte Logik in Ihrem Tarif unterstützen.
4. Prüfen Sie jeden produktiven Ersatz und dokumentieren Sie dessen Verantwortlichen und Konfiguration.

Halten Sie Checkout-Regeltests getrennt von Tests zur Bestellbearbeitung nach dem Kauf. Dokumentieren Sie für jedes System verantwortliche App, aktivierte Funktionen sowie Fulfillment- und Zahlungsverhalten, damit künftige Änderungen eine klare Zuständigkeit haben.

Ressourcen#

• Überblick über Shopify Functions — Shopify Developer Docs
• Von Shopify Scripts zu Functions migrieren
• Anleitung zum Erstellen einer Rabatt-Function
• API-Referenz für Delivery Customization Functions
• API-Referenz für Payment Customization Functions
• Dokumentation zur Shopify CLI

Weiterführende Artikel: Revize, 2026 · Kunden ihre Shopify-Bestellungen selbst bearbeiten lassen