Shopify Scripts: Bestellungen bis 30. Juni 2026 auf Functions umstellen

Heute ist der 16. April 2026. Gestern, am 15. April, hat Shopify den Script Editor endgültig gesperrt. Sie können keine neuen Scripts mehr erstellen oder veröffentlichen. Besonders betroffen ist die Logik für Änderungen nach dem Kauf: Änderungen der Versandadresse sind mit 30,2 % aller bearbeiteten Bestellungen die häufigste Änderung nach dem Kauf (Revize, 2026). Jedes Script, das solche Änderungen verarbeitet, ist jetzt eingefroren. In 75 Tagen, am 30. Juni 2026, endet die Ausführung.

Wenn Sie als Entwickler für einen Shopify Plus Shop arbeiten oder als Agentur einen Plus Shop betreuen und diese Migration seit zwölf Monaten auf den „nächsten Sprint“ verschieben, müssen Sie jetzt handeln. Es geht um einen Checkout, der ab dem 1. Juli nicht mehr wie vorgesehen funktioniert. In den meisten Plus Shops haben sich über die Jahre 5 bis 20 Scripts angesammelt. Jedes steuert im Hintergrund eine Rabattregel, blendet eine Versandart aus oder schränkt Zahlungsmethoden ein. Oft weiß niemand mehr, wer es geschrieben hat.

Dieser Leitfaden ist die technische Migrationsanleitung, die wir uns im Januar gewünscht hätten. Er behandelt den konkreten Code und nicht nur die Planung. Danach wissen Sie, wie Sie mit der Shopify CLI eine Function erstellen, die Logik für Rabatte sowie Versand- und Zahlungsanpassungen in Rust oder JavaScript schreiben, sie sicher mit einer markierten Kundengruppe testen und in Produktion bringen, ohne Ihren bestehenden Checkout zu beeinträchtigen.

Stellen wir Ihren Shop von Scripts auf Functions um.

Kurzantwort: Von Scripts zu Functions in 60 Sekunden#

Die Migration in einem Absatz: Shopify Scripts (Ruby-Code im Script Editor, nur für Plus) werden durch Shopify Functions ersetzt (WebAssembly-Module in Rust oder JavaScript, für alle Tarife verfügbar). Sie erstellen eine Function mit shopify app generate extension, schreiben eine run.graphql-Abfrage für die benötigten Warenkorbdaten und eine Datei run.rs oder run.js, die Aktionen zurückgibt, etwa Rabatte oder ausgeblendete Versandarten. Anschließend stellen Sie sie mit shopify app deploy bereit und aktivieren sie im Adminbereich oder per GraphQL-Mutation. Functions laufen als kompiliertes WASM mit einer Ausführungszeit unter 5 ms, sind in jedem Tarif nutzbar und sind künftig der einzige von Shopify unterstützte Weg für solche Anpassungen.

Was sich am 30. Juni tatsächlich ändert#

Bevor wir uns den Code ansehen, klären wir die Termine. Es gibt zwei, und beide sind wichtig.

Entweder ist Ihre Function bis zum 30. Juni bereitgestellt und Ihr Checkout funktioniert weiter wie vorgesehen, oder sie ist es nicht. Dann gelten für jeden betroffenen Warenkorb wieder die Standardpreise und regulären Versandtarife, und alle Zahlungsmethoden sind aktiviert. Eine teilweise Migration hilft nicht: Ein Script wird entweder ausgeführt oder nicht. Nach dem 30. Juni wird es nicht mehr ausgeführt.

Tipp: Öffnen Sie in Shopify Admin Settings → Checkout → Customizations Report. Der Bericht listet alle aktiven Scripts Ihres Shops, ihre Aufgaben und den jeweils empfohlenen Function-Typ als Ersatz auf. Beginnen Sie dort.

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

Der Unterschied in der Architektur ist wichtig. Bei Scripts änderten Sie Ruby-Code in einem Textfeld. Für Functions entwickeln Sie eine App, verwalten den Code in der Versionskontrolle, testen lokal und stellen ihn über eine CI-Pipeline bereit. Der Einstieg ist aufwendiger. Zugleich ist Functions Shopifys langfristiger Ansatz für die Checkout-Logik. Auf absehbare Zeit sollte dafür keine weitere Migration nötig sein.

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

Jedes Ihrer heutigen Scripts lässt sich genau einer Function-API zuordnen. Diese Tabelle hilft bei der Auswahl.

Wenn Sie zehn Scripts haben, werden Sie vermutlich drei bis fünf Functions erstellen. Mehrere Scripts lassen sich oft in einer Function mit übersichtlicheren Verzweigungen zusammenfassen.

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 18+

node --version
# Must be >= 18.0.0

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

2. Shopify CLI 3+

npm install -g @shopify/cli@latest
shopify version
# Should output 3.x or higher

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-wasip1
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 Entwicklungsshop

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 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-01"

[[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-wasip1 --release"
path = "target/wasm32-wasip1/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 {
  discountAutomaticAppCreate(
    automaticAppDiscount: {
      title: "Volume Discount (5+ collection items)"
      functionHandle: "volume-discount-fn"
      discountClasses: [ORDER]
      startsAt: "2026-04-16T00:00:00Z"
    }
  ) {
    automaticAppDiscount { discountId }
    userErrors { field message }
  }
}

Damit ist die Function aktiv, versioniert und ersetzt das bisherige Script vollständig.

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.

Schritt 2.1: Grundgerüst erstellen#

shopify app generate extension --template delivery_customization --name hide-express-fn

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

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

Schritt 2.3: Logik (src/run.js — JavaScript-Variante)#

// @ts-check
/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").FunctionRunResult} FunctionRunResult
 */

const NO_CHANGES = { operations: [] };
const THRESHOLD = 500.0;
const HIDE_TITLES = ["Express", "Overnight"];

/**
 * @param {RunInput} input
 * @returns {FunctionRunResult}
 */
export function run(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) => ({
        hide: { deliveryOptionHandle: opt.handle },
      }))
  );

  return { operations };
}

Schritt 2.4: Im Adminbereich aktivieren (kein GraphQL nötig)#

Für Delivery Customizations gibt es eine integrierte Oberfläche im Adminbereich. Nach shopify app deploy:

1. Öffnen Sie Settings → Shipping and delivery
2. Scrollen Sie nach unten zum Abschnitt Customizations
3. Klicken Sie auf Add customization und wählen Sie Ihre Function aus
4. Speichern Sie

Die Regel zum Ausblenden ist nun in Produktion aktiv. Eine Mutation ist nicht erforderlich.

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 --name hide-cod-b2b-fn

Schritt 3.2: Eingabeabfrage#

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

Schritt 3.3: Logik (src/run.js)#

const NO_CHANGES = { operations: [] };

export function run(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: [{ hide: { paymentMethodId: codMethod.id } }],
  };
}

Schritt 3.4: Aktivieren#

Auch Payment Customizations haben eine Oberfläche im Adminbereich unter Settings → Payments → Customizations. Gehen Sie wie bei der Versandanpassung vor: Function auswählen und speichern.

Ein Wort zu Änderungen nach dem Kauf#

Da Sie diesen Artikel im Blog von Revize lesen, ein kurzer Hinweis: Revize übernimmt Aufgaben, die Functions nicht abdecken. Nach einer Bestellung möchten Kunden vielleicht einen Artikel hinzufügen, eine Größe tauschen, die Versandadresse korrigieren oder einen vergessenen Rabatt anwenden. Functions greifen im Checkout. Revize greift danach. Functions bestimmen, was im Warenkorb zulässig ist. Revize ermöglicht Ihren Kunden und Ihrem Supportteam, die Bestellung anschließend zu bearbeiten, ohne sie erst zu erstatten und neu anzulegen. Das ist für zwei Arten von Shops wichtig: für Shops mit so vielen Bestellungen, dass manuelle Bearbeitung nicht mehr mithält – darunter Plus Shops, aber auch Advanced Shops mit hohem Bestellvolumen – und für Shops, deren Marke stark vom Kundenerlebnis lebt. Dort kann eine E-Mail mit „Leider können wir das nicht ändern“ den nächsten Kauf verhindern.

Wenn Ihr Migrationsplan Scripts durch Functions ersetzt, Sie aber die Bestellbearbeitung nach dem Kauf noch nicht gelöst haben, stehen Sie in etwa drei Wochen vor dem nächsten Problem. Unser kürzlich veröffentlichter Leitfaden zur Bestellverwaltung zeigt den gesamten Ablauf nach dem Checkout.

Zurück zur Migration.

Teststrategie: Kunden mit Tags schrittweise einbeziehen#

Functions haben keinen „Entwurfsmodus“, den Sie im Adminbereich ein- oder ausschalten können. In der Praxis begrenzen Sie die neue Function zunächst auf Kunden mit einem bestimmten Tag. Lassen Sie das alte Script und die neue Function parallel laufen, prüfen Sie, ob beide für diese Kunden dieselben Ergebnisse liefern, und schalten Sie die Function dann für alle frei.

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#

// At the top of your run function
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);  // Fall through to existing Script
}

// 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 Kunde mit Tag an, durchlaufen Sie den Checkout und prüfen Sie, ob die Function ausgeführt wird. Melden Sie sich anschließend als Kunde ohne Tag an und prüfen Sie, ob das alte Script weiterhin läuft. Wenn die Ergebnisse einige Tage lang übereinstimmen, entfernen Sie die Tag-Prüfung und lassen Sie die Function für alle ausführen.

Schritt 5: Das alte Script deaktivieren#

Öffnen Sie Apps → Script Editor → [Your Script] → Unpublish. Danach ist allein die Function maßgeblich.

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: '20' }
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: wasm32-wasip1 }
      - run: npm install -g @shopify/cli@latest
      - run: shopify app deploy --force
        env:
          SHOPIFY_CLI_PARTNERS_TOKEN: ${{ secrets.SHOPIFY_CLI_PARTNERS_TOKEN }}

Erstellen Sie das Partner-Token in Ihrem Partner-Dashboard unter Settings → Tokens. Danach stellt jeder Merge in main Ihre Functions bereit. Die Frage, ob jemand die letzte Änderung schon bereitgestellt hat, entfällt.

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#

Bei der Begleitung von Plus Händlern durch diese Migration sind uns im vergangenen Jahr immer wieder dieselben fünf Fehler begegnet.

1. Functions als direkte Kopie jedes Scripts behandeln. Eine Function kann drei Scripts mit übersichtlicheren Verzweigungen ersetzen. Erfassen Sie Ihre Scripts als Gesamtsystem, bevor Sie sie neu schreiben.

2. Leseberechtigungen vergessen. Viele Functions benötigen read_customers, read_orders oder write_discounts. Tragen Sie die Berechtigungen in shopify.app.toml unter scopes ein und autorisieren Sie die App erneut. Andernfalls liefert Ihre Eingabeabfrage null zurück.

3. Functions ohne Vergleichstests für Kunden ohne Tag ausführen. Auch wenn der Code richtig aussieht, können Sonderfälle Probleme aufdecken: leere Warenkörbe, Geschenkgutscheine, Shop-Guthaben oder B2B-Entwürfe. Eine schrittweise Freigabe über Tags kostet zwei Tage und kann einen schwerwiegenden Ausfall verhindern.

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 für die nächsten 75 Tage#

Ein realistischer Wochenplan, damit Sie bis zum 30. Juni fertig sind.

Wenn Sie diese Woche anfangen, haben Sie einen Puffer. Wenn Sie erst im Juni beginnen, haben Sie keinen.

Was Sie diese Woche tun sollten#

Schließen Sie nach diesem Artikel nicht einfach den Tab. Erledigen Sie in den nächsten sieben Tagen diese vier Aufgaben.

1. Rufen Sie den Customizations Report ab. Öffnen Sie Settings → Checkout → Customizations Report und exportieren Sie ihn. Das ist Ihre Aufgabenliste für die Migration.

2. Richten Sie Ihre Entwicklungsumgebung ein. Installieren Sie Node 18+, die Shopify CLI und gegebenenfalls Rust. Prüfen Sie, ob shopify version funktioniert. Zeitaufwand insgesamt: 30 Minuten.

3. Erstellen Sie eine kleine Function und stellen Sie sie in einem Entwicklungsshop bereit. Wählen Sie Ihr einfachstes Script, meist eine Regel zum Ausblenden einer Zahlungsmethode. Migrieren Sie es vollständig. Selbst wenn die Function nie in Produktion geht, haben Sie damit Ihre Entwicklungswerkzeuge geprüft.

4. Reservieren Sie für die nächsten acht Wochen feste Termine im Kalender. Eine Migration erledigt sich nicht nebenbei zwischen Sprints. Planen Sie wiederkehrende Zeitfenster ein, beispielsweise jeden Dienstag- und Donnerstagnachmittag, und behandeln Sie sie wie einen Release.

Bei den Teams, deren Migration wir begleitet haben, wiederholt sich ein Muster: zwei Wochen Aufschub, drei Wochen Arbeit, eine Woche Nachbereitung. Das sind sechs Wochen. Sie haben zehn. Nutzen Sie den Puffer für Code-Reviews und Qualitätssicherung.

Wenn Ihre Checkout-Logik steht, folgt für viele Teams die Bestellbearbeitung nach dem Kauf: Kunden ändern Adressen, tauschen Artikel oder ergänzen Rabatte nach der Bestellung. Falls das auf Ihrer Planungsliste steht – ob Sie einen Plus Shop mit hohem Bestellvolumen oder einen auf Kundenerlebnis ausgerichteten Advanced Shop betreiben –, finden Sie Revize im Shopify App Store. Die App funktioniert neben jeder Function, die Sie hier erstellen.

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

Aktualisiert im August 2026. Revize ist eine Shopify App, mit der Kunden ihre Bestellungen nach dem Kauf selbst bearbeiten können. Sie können vor dem Fulfillment die Versandadresse ändern, eine Variante oder ein Produkt tauschen, stornieren und eine Rückerstattung oder Shop-Guthaben erhalten – ohne Supportanfrage. Erfahren Sie mehr darüber, wie Kunden ihre Shopify Bestellungen selbst bearbeiten können, oder finden Sie Revize im Shopify App Store.