Shopify Scripts zu Functions migrieren: Was Händler vor der Deadline wissen müssen

Die Deadline, die viele ignorieren

Es gibt eine Frist, die sich Shopify-Plus-Händler rot im Kalender markieren sollten: August 2025. Ab diesem Zeitpunkt hat Shopify die Scripts-Engine endgültig abgeschaltet. Wer bis dahin nicht migriert hat, steht vor einem Problem — denn Scripts, die Rabatte berechnen, Versandoptionen filtern oder Zahlungsmethoden steuern, funktionieren dann schlicht nicht mehr.

Das klingt dramatisch? Ist es auch. Denn laut Shopifys eigenen Daten nutzen über 60% aller Shopify-Plus-Händler mindestens ein aktives Script. Viele davon für geschäftskritische Logik: Mengenrabatte, VIP-Pricing, Bundle-Angebote, dynamische Versandkosten. Fällt das weg, fällt Umsatz weg.

Trotzdem ist die Realität: Ein erheblicher Teil dieser Händler hat die Migration noch nicht begonnen. Die Gründe sind nachvollziehbar — Functions sind ein fundamental anderes System, die Dokumentation ist umfangreich aber nicht immer praxisnah, und der Aufwand wird unterschätzt.

Dieser Artikel liefert Ihnen alles, was Sie für die Migration brauchen. Keine Theorie ohne Praxis, keine Schönfärberei, keine Lücken.

Was passiert — und warum

Die Timeline im Überblick

Shopify hat den Abschied von Scripts über mehrere Jahre angekündigt. Hier die relevanten Meilensteine:

• 2022: Shopify stellt Functions als Beta vor (Shopify Editions Summer '22)
• 2023: Functions werden General Available. Erste Migrationswarnungen im Admin-Dashboard
• 2024: Shopify sperrt die Erstellung neuer Scripts. Bestehende Scripts laufen weiter, können aber nicht mehr bearbeitet werden
• August 2025: Scripts-Engine wird vollständig abgeschaltet. Alle aktiven Scripts stoppen
• Ab August 2025: Nur noch Functions stehen für serverseitige Checkout-Logik zur Verfügung

Was passiert, wenn Sie nicht migrieren

Konkret: Ihre Scripts laufen einfach nicht mehr. Das bedeutet:

• Rabatte verschwinden: Automatische Rabatte, die per Script berechnet wurden, greifen nicht mehr. Kunden sehen den vollen Preis.
• Versandlogik bricht: Wenn Sie per Script Versandoptionen gefiltert oder Preise angepasst haben, sehen Kunden wieder alle Standard-Optionen.
• Zahlungsfilter fallen weg: Payment-Scripts, die bestimmte Zahlungsmethoden je nach Warenkorbinhalt ein- oder ausblenden, funktionieren nicht mehr.

Es gibt keine Übergangsfrist, keine Soft-Deprecation, kein "es läuft noch irgendwie". Der Schalter wird umgelegt.

Scripts vs. Functions — der ehrliche Vergleich

Bevor Sie migrieren, sollten Sie verstehen, was sich technisch ändert. Die beiden Systeme unterscheiden sich fundamental.

Kernunterschied: Scripts manipulieren Objekte direkt ("Setze den Preis auf X"). Functions deklarieren Veränderungen ("Ich schlage vor, den Preis um Y zu reduzieren, und Shopify entscheidet, ob das angewendet wird"). Das ist ein Paradigmenwechsel, kein einfaches Umschreiben.

Wofür Scripts typischerweise eingesetzt werden

In unserer Erfahrung aus dutzenden Shopify-Plus-Projekten sehen wir diese Script-Typen am häufigsten:

1. Line Item Scripts (Produktrabatte)

Der mit Abstand häufigste Anwendungsfall. Beispiele:

• Mengenrabatte: Ab 5 Stück 10% Rabatt, ab 10 Stück 20%
• Bundle-Rabatte: Produkt A + Produkt B zusammen = 15% auf beides
• Kundenspezifische Preise: VIP-Kunden sehen andere Preise
• Automatische Gratisprodukte: Ab 100 EUR Warenkorbwert ein Gratisprodukt
• BOGO (Buy One Get One): Kauf 2, zahl 1

2. Shipping Scripts (Versandanpassungen)

• Versandoptionen ausblenden: Express-Versand erst ab 50 EUR anzeigen
• Versandpreise anpassen: Gratis-Versand ab bestimmtem Warenkorbwert
• Regionale Einschränkungen: Bestimmte Versandarten nur für bestimmte PLZ-Bereiche
• Gewichtsbasierte Anpassungen: Versandkosten dynamisch nach Gewicht berechnen

3. Payment Scripts (Zahlungsmethoden)

• Zahlungsarten filtern: Rechnung nur für Bestandskunden
• Zahlungsarten sortieren: Bevorzugte Zahlungsart nach oben
• Betragsbasierte Filter: PayPal nur bis 500 EUR anzeigen
• Länderbasierte Filter: Bestimmte Zahlungsarten nur in bestimmten Ländern

Die Functions-Äquivalente — mit Code-Beispielen

Für jeden Script-Typ gibt es ein Functions-Pendant. Die Architektur ist aber grundlegend anders: Statt imperativem Ruby-Code schreiben Sie deklarative Functions, die über eine GraphQL-API Input erhalten und strukturierten Output zurückgeben.

Discount Functions (Ersatz für Line Item Scripts)

Shopify bietet drei Discount-Function-Typen:

• Product Discount: Rabatte auf einzelne Produkte
• Order Discount: Rabatte auf die gesamte Bestellung
• Shipping Discount: Rabatte auf Versandkosten

Hier ein konkretes Beispiel: Ein Mengenrabatt, der ab 5 Stück 10% Rabatt gewährt.

Altes Script (Ruby):

Input.cart.line_items.each do |line_item|
  if line_item.quantity >= 5
    line_item.change_line_price(
      line_item.line_price * 0.9,
      message: "10% Mengenrabatt"
    )
  end
end

Output.cart = Input.cart

Neue Function (JavaScript) — Input Query:

query RunInput {
  cart {
    lines {
      id
      quantity
      merchandise {
        ... on ProductVariant {
          id
          product {
            title
          }
        }
      }
      cost {
        amountPerQuantity {
          amount
          currencyCode
        }
      }
    }
  }
}

Neue Function (JavaScript) — Logic:

// src/run.js
export function run(input) {
  const discounts = [];

  input.cart.lines.forEach((line) => {
    if (line.quantity >= 5) {
      discounts.push({
        targets: [
          {
            productVariant: {
              id: line.merchandise.id,
            },
          },
        ],
        value: {
          percentage: {
            value: "10.0",
          },
        },
        message: "10% Mengenrabatt",
      });
    }
  });

  return {
    discounts: discounts,
    discountApplicationStrategy: "FIRST",
  };
}

Wichtig: Beachten Sie den Unterschied. Das Script ändert den Preis direkt. Die Function gibt eine Rabatt-Deklaration zurück, die Shopify dann anwendet. Sie haben keine direkte Kontrolle über den Endpreis — Sie deklarieren nur Ihre Absicht.

Cart Transform Functions (Ersatz für Bundle-Logik)

Cart Transform Functions ermöglichen es, den Warenkorb zu modifizieren — z.B. um Produkte zu bündeln oder automatisch Gratisprodukte hinzuzufügen.

query RunInput {
  cart {
    lines {
      id
      quantity
      merchandise {
        ... on ProductVariant {
          id
          product {
            id
            title
            hasAnyTag(tags: ["bundle-eligible"])
          }
        }
      }
    }
  }
}

// Cart Transform: Bundle-Erstellung
export function run(input) {
  const operations = [];
  const bundleItems = input.cart.lines.filter(
    (line) => line.merchandise.product.hasAnyTag
  );

  if (bundleItems.length >= 2) {
    operations.push({
      merge: {
        parentVariantId: bundleItems[0].merchandise.id,
        title: "Produkt-Bundle",
        cartLines: bundleItems.map((item) => ({
          cartLineId: item.id,
          quantity: item.quantity,
        })),
        price: {
          percentageDecrease: {
            value: "15.0",
          },
        },
      },
    });
  }

  return { operations };
}

Payment Customization Functions (Ersatz für Payment Scripts)

Payment Customization Functions steuern, welche Zahlungsmethoden im Checkout angezeigt werden.

// Payment Customization: Rechnung nur für Bestandskunden
export function run(input) {
  const operations = [];

  // Prüfe ob der Kunde ein Bestandskunde ist (via Metafield)
  const isExistingCustomer =
    input.cart.buyerIdentity?.customer?.metafield?.value === "true";

  if (!isExistingCustomer) {
    // Rechnung ausblenden für Neukunden
    const invoiceMethod = input.paymentMethods.find((method) =>
      method.name.includes("Rechnung")
    );

    if (invoiceMethod) {
      operations.push({
        hide: {
          paymentMethodId: invoiceMethod.id,
        },
      });
    }
  }

  return { operations };
}

Delivery Customization Functions (Ersatz für Shipping Scripts)

// Delivery Customization: Express nur ab 50 EUR anzeigen
export function run(input) {
  const operations = [];
  const cartTotal = parseFloat(input.cart.cost.totalAmount.amount);

  if (cartTotal < 50) {
    input.deliveryGroups.forEach((group) => {
      group.deliveryOptions.forEach((option) => {
        if (option.title.toLowerCase().includes("express")) {
          operations.push({
            hide: {
              deliveryOptionHandle: option.handle,
            },
          });
        }
      });
    });
  }

  return { operations };
}

Migration Schritt für Schritt

Schritt 1: Audit Ihrer aktuellen Scripts

Bevor Sie irgendetwas bauen, brauchen Sie eine vollständige Bestandsaufnahme. Gehen Sie in Ihren Shopify Admin unter Apps > Script Editor und dokumentieren Sie:

• Welche Scripts sind aktiv? (Name, Typ, Status)
• Was genau tut jedes Script? (Geschäftslogik in Klartext formulieren)
• Welche Produkte/Collections sind betroffen? (Scope)
• Welche Bedingungen gibt es? (Kundengruppen, Warenkorbwert, Mengen, Tags)
• Gibt es Abhängigkeiten zwischen Scripts? (Script A setzt voraus, dass Script B gelaufen ist)

Erstellen Sie eine Tabelle wie diese:

Schritt 2: Scripts auf Functions mappen

Ordnen Sie jedem Script den passenden Function-Typ zu:

Schritt 3: Entwicklungsumgebung einrichten

Functions werden über die Shopify CLI entwickelt und deployed. Die Einrichtung:

// 1. Node.js installieren (v18+ empfohlen)
// 2. Shopify CLI installieren
npm install -g @shopify/cli

// 3. Neues App-Projekt erstellen (oder bestehendes nutzen)
shopify app init

// 4. Function erstellen
shopify app generate extension --type product_discounts
// Oder: order_discounts, shipping_discounts,
// delivery_customization, payment_customization,
// cart_transform

Die CLI generiert eine Projektstruktur mit:

• input.graphql — Die GraphQL-Query, die den Input definiert
• src/run.js (oder src/run.rs für Rust) — Die eigentliche Logik
• shopify.extension.toml — Konfigurationsdatei

Schritt 4: Functions bauen und testen

Entwickeln Sie die Function-Logik basierend auf Ihrem Script-Audit. Für jede Function:

1. Input Query definieren: Welche Daten braucht die Function? Warenkorbinhalt, Kundeninfos, Metafields?
2. Logik implementieren: Die run()-Funktion, die Input verarbeitet und Output zurückgibt
3. Lokal testen: Die Shopify CLI bietet einen Preview-Modus

// Lokales Testen mit der Shopify CLI
shopify app function run --input input.json

// input.json enthält Testdaten:
{
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 6,
        "merchandise": {
          "id": "gid://shopify/ProductVariant/123",
          "product": {
            "title": "Test-Produkt"
          }
        },
        "cost": {
          "amountPerQuantity": {
            "amount": "29.99",
            "currencyCode": "EUR"
          }
        }
      }
    ]
  }
}

Tipp: Erstellen Sie mehrere Test-Inputs: Warenkorb mit einem Produkt, Warenkorb mit vielen Produkten, Warenkorb unterhalb und oberhalb der Rabatt-Schwelle, leerer Warenkorb. Edge Cases sind der häufigste Grund für Produktionsprobleme.

Schritt 5: Deployen und validieren

// Function deployen
shopify app deploy

// Im Shopify Admin:
// 1. Gehe zu Einstellungen > Apps und Vertriebskanäle
// 2. Wähle Deine App aus
// 3. Aktiviere die Function
// 4. Konfiguriere die Einstellungen (welche Produkte, welche Bedingungen)

Validierungscheckliste:

• Function ist im Shopify Admin sichtbar und aktiviert
• Rabatte werden korrekt berechnet (mehrere Testbestellungen)
• Edge Cases funktionieren (leerer Warenkorb, Einzelstück, Großbestellung)
• Performance ist akzeptabel (unter 5ms Ausführungszeit)
• Keine Konflikte mit anderen Discount-Codes oder automatischen Rabatten
• Mobile Checkout funktioniert identisch zum Desktop
• Mehrwährungsfähigkeit getestet (falls relevant)

Schritt 6: Alte Scripts entfernen

Erst wenn die Functions mindestens eine Woche in Produktion fehlerfrei laufen, deaktivieren Sie die alten Scripts. Nicht vorher. Führen Sie parallele Tests durch und vergleichen Sie die Ergebnisse.

Häufige Fallstricke bei der Migration

1. Functions können nicht alles, was Scripts konnten

Das ist die unbequeme Wahrheit. Einige Script-Features haben kein direktes Function-Äquivalent:

• Direkte Preismanipulation: Scripts konnten den Preis eines Line Items direkt setzen ("Setze den Preis auf 19,99 EUR"). Functions können nur prozentuale oder fixe Rabatte deklarieren.
• Mehrere Rabatte auf ein Produkt: Scripts konnten mehrere Rabatte stapeln. Functions haben eine discountApplicationStrategy ("FIRST" oder "MAXIMUM"), die bestimmt, welcher Rabatt gewinnt.
• Line Item Properties lesen/schreiben: Scripts konnten Line Item Properties direkt manipulieren. Functions haben hier eingeschränkten Zugriff.

2. Keine Netzwerk-Calls

Das war schon bei Scripts so, und es bleibt bei Functions: Kein HTTP, kein API-Call, keine externe Datenbank. Alles, was die Function braucht, muss über den GraphQL-Input oder Metafields kommen.

Wenn Ihr Script eine externe Preisdatenbank abfragt, müssen Sie die Daten vorher in Metafields synchronisieren — z.B. über einen Webhook oder einen Cronjob.

3. Das Input/Output-Modell ist fundamental anders

Scripts arbeiten imperativ: Sie bekommen ein Objekt, manipulieren es direkt, und geben es zurück. Functions arbeiten deklarativ: Sie bekommen einen Input, analysieren ihn, und geben eine Liste von Operationen zurück, die Shopify dann ausführt.

Das klingt nach einem kleinen Unterschied. In der Praxis bedeutet es, dass Sie Ihre Logik von Grund auf neu denken müssen. Ein "Umschreiben" von Ruby nach JavaScript reicht nicht — Sie müssen die gesamte Denkweise ändern.

4. Testing ist aufwändiger

Scripts konnten Sie im Script Editor testen — Script eingeben, Testbestellung aufgeben, Ergebnis prüfen. Functions erfordern einen vollständigen Entwicklungs-Workflow: Lokale Entwicklung, Unit Tests, Deployment, Aktivierung, Testbestellung.

Das ist langfristig besser (weil testbar und versioniert), aber der initiale Aufwand ist höher.

5. Performance-Limits sind strikt

Functions haben ein hartes Limit von 5ms Ausführungszeit und ein Speicherlimit von 256KB. Für die meisten Anwendungsfälle ist das kein Problem — WebAssembly ist schnell. Aber wenn Ihre Logik komplexe Berechnungen über hunderte Line Items durchführt, müssen Sie optimieren.

Praxisregel: Vermeiden Sie verschachtelte Schleifen über Cart Lines. Nutzen Sie Maps statt Arrays für Lookups. Minimieren Sie die Menge der angeforderten Daten im Input Query.

Was tun, wenn es kein Function-Äquivalent gibt?

Nicht jedes Script lässt sich 1:1 migrieren. Hier sind die Strategien für diese Fälle:

Checkout UI Extensions als Ergänzung

Checkout UI Extensions können Function-Lücken schließen. Beispiel: Wenn Sie im Checkout dynamisch Informationen anzeigen müssen (z.B. "Sie sparen X EUR" oder "Noch Y EUR bis zum Gratis-Versand"), können UI Extensions das übernehmen, während die Function die eigentliche Rabattlogik steuert.

Kombinations-Ansätze

Oft lässt sich ein komplexes Script durch eine Kombination aus mehreren Functions und Extensions abbilden:

• Function für die Rabattberechnung
• Checkout UI Extension für die Darstellung
• Metafields als Datenspeicher für Konfigurationen
• Shopify Flow für Automatisierungen rund um die Function

Akzeptieren, was nicht geht

Manchmal ist die ehrliche Antwort: Diese spezifische Logik ist mit Functions nicht möglich. In diesen Fällen gibt es zwei Optionen:

1. Geschäftsprozess anpassen: Wenn ein Script eine sehr spezifische Rabattlogik implementiert hat, die sich nicht abbilden lässt — kann die Rabattstruktur vereinfacht werden?
2. Workaround über Draft Orders: Für B2B-Szenarien mit komplett individuellen Preisen können Draft Orders mit manuell gesetzten Preisen eine Alternative sein.

Die gute Nachricht: Shopify erweitert den Function-Umfang kontinuierlich. Was heute nicht geht, kann in sechs Monaten möglich sein.

Kosten und Aufwand realistisch einschätzen

Hier die Erfahrungswerte aus unseren Migrationsprojekten:

Einfache Migrationen (1-2 Tage)

• Ein einzelnes Script mit klarer Logik
• Mengenrabatt, einfacher prozentualer Rabatt, Gratis-Versand ab Betrag X
• Keine komplexen Bedingungen, keine Abhängigkeiten
• Kosten: ca. 800 - 1.500 EUR

Mittlere Migrationen (1-2 Wochen)

• 3-5 Scripts mit unterschiedlichen Typen
• Verschachtelte Bedingungen (Kundengruppe + Warenkorbwert + Produkttyp)
• Bundle-Logik oder tiered Pricing
• Parallelbetrieb und ausführliche Tests
• Kosten: ca. 3.000 - 6.000 EUR

Komplexe Migrationen (2-4 Wochen)

• 5+ Scripts mit Abhängigkeiten untereinander
• Komplexe B2B-Preislogik mit kundenspezifischen Rabatten
• Custom Checkout Flows, die Scripts + Theme-Anpassungen kombinieren
• Internationale Shops mit unterschiedlichen Regeln pro Markt
• Kosten: ca. 6.000 - 15.000 EUR

Realitätscheck: Die Kosten der Migration sind fast immer geringer als der Umsatzverlust, wenn Scripts plötzlich nicht mehr laufen. Ein Shop mit 500.000 EUR Monatsumsatz, der 10% seiner Bestellungen über Script-Rabatte abwickelt, verliert potenziell 50.000 EUR pro Monat an Kundenabsprüngen und falscher Preisdarstellung.

Was den Aufwand in die Höhe treibt

• Fehlende Dokumentation: Wenn niemand mehr weiß, warum ein Script existiert oder was genau es tut
• Undokumentierte Abhängigkeiten: Script A funktioniert nur, weil Script B bestimmte Werte setzt
• Keine Testdaten: Ohne definierte Testfälle dauert die Validierung länger
• Parallelbetrieb: Scripts und Functions gleichzeitig laufen zu lassen erfordert sorgfältige Koordination, damit Rabatte nicht doppelt greifen

Migrations-Checkliste

Nutzen Sie diese Checkliste als Leitfaden für Ihr Migrationsprojekt:

Vorbereitung:

• Alle aktiven Scripts dokumentiert (Name, Typ, Logik, betroffene Produkte)
• Geschäftliche Prioritäten geklärt (welche Scripts sind geschäftskritisch?)
• Function-Typ für jedes Script identifiziert
• Fälle ohne direktes Äquivalent identifiziert und Workarounds geplant
• Entwicklungsumgebung eingerichtet (Shopify CLI, Partner-Account, Dev-Store)

Entwicklung:

• Input Queries für alle Functions definiert
• Function-Logik implementiert und Unit-getestet
• Edge Cases getestet (leerer Warenkorb, Einzelstück, Extremwerte)
• Performance validiert (unter 5ms, unter 256KB Speicher)
• Metafield-Konfigurationen angelegt (falls nötig)

Deployment:

• Functions auf Dev-Store deployed und getestet
• Functions auf Produktions-Store deployed (aber noch nicht aktiviert)
• Parallelbetrieb mit Scripts getestet (Ergebnisse vergleichen)
• Functions aktiviert, Scripts deaktiviert
• Monitoring eingerichtet (Rabatte korrekt? Fehler im Log?)

Nach der Migration:

• Mindestens eine Woche Monitoring ohne Auffälligkeiten
• Scripts endgültig entfernt
• Dokumentation aktualisiert
• Team geschult (wer kann Functions anpassen?)

Die strategische Perspektive

Die Migration von Scripts zu Functions ist nicht nur eine technische Pflichtaufgabe. Sie ist eine Chance.

Functions sind das bessere System. Sie sind schneller, flexibler, besser testbar, und sie stehen allen Shopify-Plänen zur Verfügung — nicht nur Plus. Sie sind versioniert, deployen über CI/CD, und sie lassen sich über Metafields konfigurieren, ohne Code anzufassen.

Wer die Migration als Anlass nimmt, seine gesamte Rabatt- und Checkout-Logik zu überdenken, kommt am Ende mit einem saubereren, wartbareren und leistungsfähigeren System heraus.

Aber die Uhr tickt. Wer im Sommer 2025 noch nicht migriert hat, wird unter Zeitdruck arbeiten — und Zeitdruck führt zu Fehlern, die im Checkout direkt Umsatz kosten.

TG-AI übernimmt Ihre Scripts-Migration

Wir haben Scripts-zu-Functions-Migrationen für Shopify-Plus-Händler unterschiedlicher Branchen und Komplexitätsstufen durchgeführt. Unser Vorgehen:

1. Kostenloser Script-Audit: Wir analysieren Ihre bestehenden Scripts und erstellen eine Migrationsmatrix mit Aufwandschätzung.
2. Priorisierte Migration: Geschäftskritische Scripts zuerst. Parallelbetrieb bis alles validiert ist.
3. Saubere Implementierung: Functions in JavaScript oder Rust, vollständig getestet, dokumentiert und versioniert.
4. Wissenstransfer: Ihr Team versteht, wie die neuen Functions funktionieren und wie sie angepasst werden können.

Die Deadline ist gesetzt. Die Frage ist nicht ob Sie migrieren, sondern wann — und ob Sie es unter Zeitdruck oder mit Vorlauf tun.

Sprechen Sie mit uns, bevor es eng wird.