Shopify Functions — Custom Discounts, Shipping und Payment Logic: 2026 Developer Guide

Im August 2025 hat Shopify Shopify Scripts endgültig abgeschaltet. Ein Plus Händler aus dem Rheinland rief uns 48 Stunden später an: sein Checkout warf bei 60% der Bestellungen einen Fehler, drei automatische B2B-Rabatte funktionierten nicht mehr, und seine Operations-Abteilung musste Bestellungen manuell korrigieren. Der vorige Dienstleister hatte 18 Monate lang gewusst, dass Scripts deprecated sind, aber nichts unternommen. Drei Wochen Krisenmodus später hatten wir vier Shopify Functions live, der Checkout lief wieder sauber, und der Händler hatte 80 manuelle Stunden pro Monat zurückgewonnen.

Diese Geschichte ist in 2026 nicht ungewöhnlich. Shopify Functions ist nicht optional — es ist der einzige unterstützte Weg, serverseitige Custom Logic in einem Shopify Plus Store zu schreiben. Wer in 2026 noch glaubt, ein Discount-Code im Admin oder eine Marketplace-App reiche aus, hat entweder einen sehr einfachen Use Case oder verliert Marge an unnötige manuelle Arbeit.

Dieser Leitfaden ist eine vollständige technische Referenz für Shopify Plus Entwickler, technische CTOs und Agenturen, die Functions evaluieren. Wir gehen die sieben verfügbaren Function APIs durch, zeigen echten Code in Rust und JavaScript, behandeln den Build-Workflow mit Shopify CLI, vergleichen Sprachen, dokumentieren die Migration von Scripts und teilen eine reale Case Study mit harten Zahlen.

Was Shopify Functions ist (und was nicht)

Shopify Functions sind WebAssembly-Module, die am Shopify Edge ausgeführt werden, um die Geschäftslogik des Stores in vier Bereichen zu erweitern: Discounts, Shipping, Payment und Cart Transformation. Sie ersetzen die in 2024 abgekündigte Shopify Scripts API und sind seit Sommer 2024 die einzige unterstützte Option für serverseitige Anpassungen.

Konzeptionell läuft eine Function so: Shopify ruft Ihr Wasm-Modul mit einem Input (typischerweise der Cart-State und Kontext-Metadaten) auf, Ihr Code antwortet mit einer Liste von Operationen (Discount X anwenden, Versandmethode Y verstecken, Line Item Z teilen), und Shopify wendet die Operationen am Storefront oder Checkout an. Es gibt keinen HTTP-Roundtrip im traditionellen Sinn — die Function läuft im selben Edge-Datacenter wie der Storefront, mit typischen Latenzen zwischen 3 und 30ms.

Die wichtigsten Eigenschaften:

• Wasm-basiert: kompiliert nach WebAssembly, sandboxed, deterministisch
• Sprachen: Rust (offiziell empfohlen, beste Performance) oder JavaScript (über Javy, schneller zu schreiben)
• Größenlimit: 256KB Wasm-Bytecode pro Function
• Latenz-Budget: harte 5ms Limit für die Ausführung selbst, mit Pufferzeit für Input/Output Serialization
• Keine externen API-Aufrufe: dies ist die wichtigste Einschränkung — Functions sind hermetisch geschlossen
• Deterministisch: derselbe Input liefert immer denselben Output (kein Datum, keine Zufallszahlen ohne Workaround)

Die sieben Function APIs in 2026

Stand Mai 2026 sind sieben Function APIs in der Production verfügbar:

1. Product Discount Function — Rabatte auf einzelne Line Items oder Produktvarianten
2. Order Discount Function — Rabatte auf den gesamten Warenkorb-Subtotal
3. Shipping Discount Function — Rabatte auf Versandkosten (z.B. kostenloser Versand)
4. Delivery Customization Function — Versandmethoden verstecken, umbenennen, sortieren
5. Payment Customization Function — Zahlungsmethoden verstecken, umbenennen, sortieren
6. Cart Transform Function — Line Items expandieren (Bundles), zusammenführen oder anders darstellen
7. Cart and Checkout Validation Function — Checkout blockieren, wenn Geschäftsregeln verletzt sind

Wann Sie Functions wirklich brauchen (und wann nicht)

Bevor Sie eine Function bauen, prüfen Sie die Entscheidungsmatrix in dieser Reihenfolge:

1. Native Shopify-Regel: Reicht ein Discount-Code im Admin, eine Standard-Versandregel oder Shopify Markets? Wenn ja: machen.
2. Marketplace-App: Gibt es eine bewährte App im Shopify App Store (z.B. Discounty, Bold Discounts, Advanced Shipping Rules)? Wenn ja und Lizenzkosten unter 200 EUR/Monat liegen: meist sinnvoll.
3. Custom Function: Erst wenn Native und App nicht passen, bauen Sie eine Function.

Reale Szenarien, in denen wir Functions empfehlen:

• Tiered B2B Discounts: 5% ab 1.000 EUR, 10% ab 5.000 EUR, 15% ab 10.000 EUR — kombiniert mit Customer-Tag-basierten Multiplikatoren. Keine App löst das sauber.
• Dynamische Shipping-Regeln: Express-Versand verstecken, wenn der Cart fragile Items enthält; Speditionsversand erzwingen ab 50kg.
• Region-spezifische Payment-Hides: Rechnung nur für verifizierte B2B-Kunden in DACH; Klarna verstecken in Ländern mit hoher Stornoquote.
• Bundle-Logik: Ein gekauftes Bundle expandiert in drei Line Items für die Lagerverwaltung, bleibt aber als ein Item für den Kunden sichtbar.
• MOQ-Validierung: Checkout blockieren, wenn ein B2B-Kunde unter der Mindestbestellmenge liegt.

Die sieben Function APIs im Detail

1. Product Discount Function

Diese Function gibt eine Liste von Discount-Operationen auf einzelne Line Items zurück. Sie ist ideal für Use Cases wie „Kaufe 2 aus Kategorie X, bekomme den dritten 30% günstiger" oder „Member-only 15% auf Marken-Tag XYZ".

Input-Schema (gekürzt):

query Input {
  cart {
    lines {
      id
      quantity
      merchandise {
        ... on ProductVariant {
          id
          product {
            tags
            inAnyCollection(ids: ["gid://shopify/Collection/123"])
          }
        }
      }
    }
    buyerIdentity {
      customer {
        hasAnyTag(tags: ["vip", "wholesale"])
      }
    }
  }
  discountNode {
    metafield(namespace: "functions", key: "config") {
      value
    }
  }
}

Rust-Implementierung für „Kaufe 2 aus Collection 123, dritter 30% rabatt":

use shopify_function::prelude::*;
use shopify_function::Result;

#[shopify_function_target(query_path = "src/run.graphql", schema_path = "schema.graphql")]
fn run(input: input::ResponseData) -> Result<output::FunctionRunResult> {
    let mut eligible_lines: Vec<_> = input.cart.lines.iter()
        .filter(|line| matches!(
            &line.merchandise,
            input::InputCartLinesMerchandise::ProductVariant(v)
                if v.product.in_any_collection
        ))
        .collect();

    if eligible_lines.len() < 3 {
        return Ok(output::FunctionRunResult { discounts: vec![], discount_application_strategy: output::DiscountApplicationStrategy::FIRST });
    }

    eligible_lines.sort_by(|a, b| a.quantity.cmp(&b.quantity));
    let target_line = eligible_lines.first().unwrap();

    Ok(output::FunctionRunResult {
        discounts: vec![output::Discount {
            message: Some("Buy 2 get 30% off third".into()),
            targets: vec![output::Target::ProductVariant(
                output::ProductVariantTarget {
                    id: target_line.merchandise_variant_id().to_string(),
                    quantity: Some(1),
                },
            )],
            value: output::Value::Percentage(output::Percentage { value: 30.0.into() }),
        }],
        discount_application_strategy: output::DiscountApplicationStrategy::FIRST,
    })
}

Die JavaScript-Variante derselben Logik:

// @ts-check
export function run(input) {
  const eligible = input.cart.lines.filter(
    (line) => line.merchandise.__typename === "ProductVariant"
      && line.merchandise.product.inAnyCollection
  );

  if (eligible.length < 3) {
    return { discounts: [], discountApplicationStrategy: "FIRST" };
  }

  eligible.sort((a, b) => a.quantity - b.quantity);
  const target = eligible[0];

  return {
    discounts: [{
      message: "Buy 2 get 30% off third",
      targets: [{ productVariant: { id: target.merchandise.id, quantity: 1 } }],
      value: { percentage: { value: 30.0 } }
    }],
    discountApplicationStrategy: "FIRST"
  };
}

Gotchas: Discount-Stacking-Logik ist tricky — wenn mehrere Functions denselben Line Item rabattieren wollen, gewinnt FIRST oder MAXIMUM je nach Strategy. Testen Sie Edge Cases mit Function Runner.

2. Order Discount Function

Rabatte auf den Subtotal des gesamten Warenkorbs. Klassisches Beispiel: „Ab 200 EUR 10% Rabatt für VIP-Kunden".

#[shopify_function_target(query_path = "src/run.graphql", schema_path = "schema.graphql")]
fn run(input: input::ResponseData) -> Result<output::FunctionRunResult> {
    let subtotal: f64 = input.cart.cost.subtotal_amount.amount.into();
    let is_vip = input.cart.buyer_identity
        .as_ref()
        .and_then(|bi| bi.customer.as_ref())
        .map(|c| c.has_any_tag)
        .unwrap_or(false);

    if subtotal < 200.0 || !is_vip {
        return Ok(output::FunctionRunResult { discounts: vec![], discount_application_strategy: output::DiscountApplicationStrategy::FIRST });
    }

    Ok(output::FunctionRunResult {
        discounts: vec![output::Discount {
            message: Some("VIP 10% over 200 EUR".into()),
            targets: vec![output::Target::OrderSubtotal(output::OrderSubtotalTarget {
                excluded_variant_ids: vec![],
            })],
            value: output::Value::Percentage(output::Percentage { value: 10.0.into() }),
        }],
        discount_application_strategy: output::DiscountApplicationStrategy::FIRST,
    })
}

3. Shipping Discount Function

Rabatte auf Versandkosten — meistens „kostenloser Versand ab Schwelle X". Wichtig: dies betrifft nur den Discount auf eine bereits berechnete Shipping Rate. Um Shipping Rates komplett zu verstecken oder umzubenennen, brauchen Sie eine Delivery Customization Function (siehe nächster Abschnitt).

export function run(input) {
  const subtotal = parseFloat(input.cart.cost.subtotalAmount.amount);
  const targets = input.cart.deliveryGroups.flatMap((group) =>
    group.deliveryOptions.map((option) => ({
      deliveryOption: { handle: option.handle }
    }))
  );

  if (subtotal < 75.0 || targets.length === 0) {
    return { discounts: [], discountApplicationStrategy: "FIRST" };
  }

  return {
    discounts: [{
      message: "Free shipping over 75 EUR",
      targets,
      value: { percentage: { value: 100.0 } }
    }],
    discountApplicationStrategy: "FIRST"
  };
}

4. Delivery Customization Function

Diese Function manipuliert die Liste der angezeigten Versandmethoden. Drei Operationen sind möglich: hide, rename und move (Reihenfolge ändern). Use Case: Express-Versand verstecken, wenn der Cart Items mit Tag „fragile" enthält.

export function run(input) {
  const hasFragile = input.cart.lines.some((line) =>
    line.merchandise.__typename === "ProductVariant"
      && line.merchandise.product.hasAnyTag
  );

  if (!hasFragile) {
    return { operations: [] };
  }

  const operations = input.cart.deliveryGroups.flatMap((group) =>
    group.deliveryOptions
      .filter((option) => option.title.toLowerCase().includes("express"))
      .map((option) => ({
        hide: { deliveryOptionHandle: option.handle }
      }))
  );

  return { operations };
}

5. Payment Customization Function

Identisch zu Delivery Customization, aber für Zahlungsmethoden. Beliebter Use Case: Rechnungskauf nur für B2B-Kunden mit Tag „credit-approved" anzeigen.

export function run(input) {
  const isCreditApproved = input.cart.buyerIdentity?.customer?.hasAnyTag === true;

  if (isCreditApproved) {
    return { operations: [] };
  }

  const operations = input.paymentMethods
    .filter((method) => method.name.toLowerCase().includes("invoice")
      || method.name.toLowerCase().includes("rechnung"))
    .map((method) => ({
      hide: { paymentMethodId: method.id }
    }));

  return { operations };
}

6. Cart Transform Function

Diese Function ist mächtiger und komplexer. Sie kann Line Items expandieren (ein Bundle wird zu drei separaten Items für die Bestandsverwaltung) oder zusammenführen (drei Items werden zu einem Bundle für die Anzeige). Sie braucht Cart Transform spezifische Metafields, um Bundle-Komponenten zu definieren.

Use Case: Ein „Starter-Kit" Produkt enthält drei Komponenten. Im Storefront sieht der Kunde ein Item, in der Bestellung kommt es als drei Line Items an, sodass das WMS jede Komponente korrekt picken kann.

export function run(input) {
  const operations = input.cart.lines
    .filter((line) => line.merchandise.__typename === "ProductVariant"
      && line.merchandise.bundleComponents?.value)
    .map((line) => {
      const components = JSON.parse(line.merchandise.bundleComponents.value);
      return {
        expand: {
          cartLineId: line.id,
          expandedCartItems: components.map((c) => ({
            merchandiseId: c.variantId,
            quantity: c.quantity * line.quantity,
            price: { adjustment: { fixedPricePerUnit: { amount: c.price } } }
          }))
        }
      };
    });

  return { operations };
}

7. Cart and Checkout Validation Function

Blockiert den Checkout, wenn Business-Regeln verletzt sind. Beispiel: B2B-Kunde versucht, unter MOQ zu bestellen, oder gemischte inkompatible Produkte sind im Cart.

export function run(input) {
  const errors = [];
  const moq = 50;
  const totalQty = input.cart.lines.reduce((sum, line) => sum + line.quantity, 0);
  const isB2B = input.cart.buyerIdentity?.customer?.hasAnyTag === true;

  if (isB2B && totalQty < moq) {
    errors.push({
      localizedMessage: `B2B minimum order is ${moq} units. Current cart: ${totalQty}.`,
      target: "$.cart"
    });
  }

  return { errors };
}

Build- und Deploy-Workflow

Der vollständige Functions-Workflow basiert auf Shopify CLI 3.x. Setup einmalig pro Maschine:

npm install -g @shopify/cli @shopify/app
shopify version  # sollte 3.50.0 oder neuer sein
shopify app init my-functions-app --template=remix
cd my-functions-app
shopify app generate extension --type=product_discounts --name=tiered-b2b-discount

Die Function wird in extensions/tiered-b2b-discount/ generiert mit src/run.ts oder src/lib.rs, einem GraphQL-Query-File und der Shopify-Konfiguration. Lokales Testen mit Function Runner:

cat test-input.json   # contains: { "cart": { "lines": [...] } }
shopify app function run --path=extensions/tiered-b2b-discount < test-input.json

Deployment:

shopify app deploy

Jeder Deploy erzeugt eine neue Version. Im Shopify Admin können Sie zwischen Versionen wechseln — wichtig für Rollback bei Production-Bugs. Versionen werden über die Shopify Partners API nummeriert; in 2026 ist die Versions-API stabil und unterstützt Versions-Pinning pro Function.

Rust vs JavaScript — welche Sprache wählen?

Beide Sprachen kompilieren zu Wasm, beide sind offiziell unterstützt, beide laufen am selben Edge. Aber die Trade-offs sind real:

Dimension	Rust	JavaScript (Javy)
Cold-Latenz	3-5ms	10-30ms
Bytecode-Größe	30-100KB typisch	80-220KB typisch
Lernkurve	steil (Borrow Checker, Lifetimes)	flach (modernes ES6/TS)
Schreibgeschwindigkeit	2-3x langsamer	baseline
Type Safety	kompilierzeit-sicher	nur mit TypeScript
JSON-Handling	serde, etwas verbose	nativ, einfach
Wasm-Toolchain	cargo + wasm-pack reif	Javy stabil seit 2024

Unsere Empfehlung in 2026:

• JavaScript für: einfache Discount-Logik, schnelle Prototypen, Teams ohne Rust-Erfahrung, Functions mit unter 50 Zeilen Logik
• Rust für: rechenintensive Validation Functions, Cart Transform mit großen Bundle-Hierarchien, komplexe Tiered Discount Engines, Functions die nahe ans 256KB Limit kommen

Praktische Faustregel: 70% unserer Functions schreiben wir in JavaScript, 30% in Rust. Die Performance-Differenz ist real, aber für die meisten Use Cases unterhalb der menschlichen Wahrnehmungsschwelle.

Migration von Shopify Scripts zu Functions

Wer in 2026 noch nicht migriert ist, hat ein Problem — Scripts wurden im August 2025 vollständig deaktiviert. Die Migration ist aber nicht 1:1, weil das Programmiermodell fundamental anders ist.

Alter Script-Typ	Neue Function API	Migrationsschwierigkeit
Line Item Script	Product Discount Function	einfach
Shipping Script	Delivery Customization + Shipping Discount	mittel (zwei Functions nötig)
Payment Script	Payment Customization Function	einfach
Bundle Logic (informell)	Cart Transform Function	schwer (neue Datenmodellierung)
MOQ-Validierung	Cart and Checkout Validation Function	einfach

Die häufigsten Stolperfallen bei der Migration:

1. Externe API-Aufrufe: Scripts hatten manchmal Workarounds für externe Calls. Functions können das nicht. Sie müssen die Daten ins Cart-Metafield-Modell migrieren.
2. Customer-Tag-Logik: Tags sind nun explizit über hasAnyTag abfragbar. Wer früher Customer-Notes parst, muss umstellen.
3. Discount-Stacking: Functions haben explizite discountApplicationStrategy. Prüfen Sie, ob FIRST, MAXIMUM oder ALL Ihrer alten Logik entspricht.
4. Test-Coverage: Scripts wurden im Live-Checkout getestet. Functions brauchen Function Runner und idealerweise einen automatisierten Test-Suite.

Case Study — Plus Händler spart 180K EUR Marge mit 4 Functions

Ein Shopify Plus Händler aus Nordrhein-Westfalen, anonymisiert auf Anfrage, betreibt einen B2B + DTC Hybrid mit etwa 4,2 Mio EUR Jahresumsatz. Die Situation im Februar 2026:

• Scripts seit August 2025 deaktiviert, Notlösung über manuelle Discount Codes
• Ops-Team verbringt 80 Stunden/Monat mit manuellen Korrekturen
• Discount-Fehler kosten 12-18K EUR/Monat in zu viel gewährten Rabatten
• B2B-Kunden beschweren sich über fehlende Tier-Discounts
• Express-Versand wird auch für fragile Glas-Items angeboten — 7% Bruchquote

In 8 Wochen haben wir vier Functions gebaut:

1. Tiered B2B Order Discount Function (Rust) — vier Tier-Stufen, kombiniert mit Customer-Tag-Multiplikator für Top-Kunden
2. Fragile Items Delivery Customization Function (JavaScript) — versteckt Express-Versand wenn Tag „fragile" im Cart
3. B2B Invoice Payment Customization Function (JavaScript) — Rechnung nur für credit-approved Customers
4. Bundle Cart Transform Function (Rust) — drei Starter-Kits expandieren zu Komponenten für WMS-Picking

Ergebnis nach drei Monaten Laufzeit:

• Discount-Fehler: 14K EUR/Monat → 200 EUR/Monat
• Manuelle Ops-Stunden: 80/Monat → 6/Monat
• Bruchquote bei Glas-Items: 7% → 0,4%
• Durchschnittlicher B2B-Order-Wert: +18% durch korrekt angewendete Tier-Discounts
• Annualisierter Effekt: ca. 180K EUR Marge zurückgewonnen

Investition: 24K EUR Implementierung, 800 EUR/Monat Wartungsretainer. ROI nach Monat 2 erreicht.

Unser typischer Functions-Delivery-Prozess

Woche 1: Discovery

Wir mappen alle bestehenden Custom-Logik-Anforderungen, extrahieren legacy Scripts (falls noch vorhanden), interviewen Ops und Sales zu manuellen Prozessen, identifizieren die Datenquellen (Customer Tags, Metafields, Collections). Output: ein Dokument mit jeder geplanten Function, Input-Daten und Erfolgs-Kriterien.

Woche 2: Architektur

Sprachenwahl pro Function (Rust vs JavaScript), Metafield-Schema-Design, GraphQL-Query-Modellierung, Test-Strategie, Deploy-Pipeline. Wir bauen das App-Skelett mit Shopify CLI und committen das Repo.

Woche 3-7: Implementierung

Pro Function: Skeleton, GraphQL-Query, Logik, Unit-Tests, Function Runner Integrationstests. Bei vier Functions sind das typischerweise 3-5 Wochen, je nach Komplexität.

Woche 8: Testing & Deployment

Vollständige End-to-End-Tests im Dev-Store, Performance-Profiling, Production-Deploy mit Versions-Pinning, A/B-Test-Phase über zwei Wochen für kritische Functions.

Ongoing: Handover

Dokumentation, Monitoring-Setup über Shopify Functions Logs API, Wartungsretainer für API-Versions-Updates und kleine Logik-Anpassungen.

Beste Shopify Apps und Tools für Functions-Entwicklung in 2026

Tool	Zweck	Wann einsetzen
Shopify CLI 3.x	Function-Scaffolding, lokales Testen, Deploy	Pflicht — Basis-Tool jedes Function-Projekts
Function Runner	Lokale Function-Ausführung mit Test-Inputs	Während der Entwicklung, vor jedem Deploy
GraphQL Admin API Explorer	Query-Entwicklung, Schema-Inspektion	Bei jeder neuen Function zur Input-Validierung
Shopify Functions API Reference	Offizielle Schema-Dokumentation	Lookup für Output-Shapes und Strategies
App Bridge	Admin-UI-Konfiguration für Functions	Wenn Merchants die Function-Parameter selbst konfigurieren sollen
Polaris Components	UI-Library für Admin-Einstellungs-Panels	Standard für jede Configuration UI
Shopify Flow	Workflow-Orchestrierung um Functions herum	Wenn Function-Trigger durch andere Events ausgelöst werden
Klaviyo Server-Side Events	Trigger Marketing-Events nach Discount-Anwendung	Für DTC-Marken mit aggressiver E-Mail-Automation
VS Code Shopify Extension	Syntax-Highlighting für Liquid + Functions	DX-Verbesserung in jedem Shopify-Projekt
wasm-pack	Rust-zu-Wasm-Toolchain	Für jede Rust-basierte Function
Hydrogen Storefront	Frontend-Integration mit Functions	Bei Headless-Setups mit Custom Cart UI
Postman / Insomnia	Admin-API-Testing für Metafield-Setup	Bei jeder Function mit Konfigurations-Metafields

Häufig gestellte Fragen

Muss ich Rust können, um Shopify Functions zu nutzen?

Nein. JavaScript über die Javy-Toolchain ist offiziell unterstützt und reicht für die Mehrheit der Functions. Rust hat etwa 3-5x bessere Cold-Latenz und engeren Bytecode, aber der Performance-Unterschied ist für einfache Discount-Logik kaum spürbar. Wir empfehlen JavaScript als Default, Rust nur für rechenintensive Cart Transform oder Validation Functions.

Sind Functions in Shopify Plus inklusive oder kostet es extra?

Functions selbst sind in jedem Shopify-Plan kostenlos enthalten — Sie zahlen keine Per-Execution-Gebühren wie bei Lambda. Es gibt jedoch Limits pro Merchant: maximal 5 Discount Functions, 1 Cart Transform Function, 5 Validation Functions pro Store (Stand Mai 2026). Custom-App-Lizenzkosten oder Agency-Stunden für die Entwicklung sind separat.

Können Functions externe APIs aufrufen?

Nein, und das ist die wichtigste Einschränkung. Functions sind hermetisch geschlossen — sie laufen Wasm-sandboxed mit einem fixen Latenz-Budget. Alle Daten, die Sie brauchen, müssen aus dem Cart-Input, Customer-Daten oder Metafields kommen. Wenn Ihre Logik externe Daten braucht, müssen Sie diese über einen Background-Job in Metafields synchronisieren (typischerweise über Shopify Flow oder eine separate App).

Welcher Latenz-Impact entsteht im Checkout?

Typisch 3-5ms für Rust, 10-30ms für JavaScript. Im Vergleich zu einer 800ms-Checkout-Roundtrip ist das vernachlässigbar. Shopify enforced ein hartes 5ms-Ausführungslimit pro Function — wenn Sie das überschreiten, wird die Function abgebrochen und die Operationen ignoriert. Functions werden parallelisiert, wo möglich.

Wie teste ich eine Function vor dem Live-Gang?

Drei Stufen: (1) Function Runner für synthetische Inputs während der Entwicklung. (2) Development Store Deploy für End-to-End-Tests im echten Cart-Flow. (3) Staging Store oder ein Plus Branch Store für Pre-Production-Tests mit echten Payment-Methods. Wir empfehlen automatisierte Function-Runner-Tests in der CI-Pipeline.

Was passiert mit Functions, wenn Shopify eine neue API-Version rollt?

Functions sind explizit an eine API-Version gebunden (z.B. 2025-10). Wenn Shopify eine neue Version rollt, läuft Ihre Function weiter auf der alten Version, bis Sie aktiv migrieren. Shopify gibt typischerweise 12 Monate Migrations-Fenster pro Version. Versions-Migration bedeutet: GraphQL-Query updaten, Output-Shapes ggf. anpassen, neu deployen, alte Version archivieren.

Fazit — alle Teile zusammenführen

Shopify Functions ist 2026 keine Option mehr, sondern Pflicht für jeden Plus-Händler mit nicht-trivialer Geschäftslogik. Die alten Scripts sind tot, der App-Markt deckt nur die häufigsten 60% der Anwendungsfälle ab, und alles, was Ihre Marge oder Ops-Effizienz wirklich beeinflusst, läuft über Custom Functions. Wer das ignoriert, zahlt entweder mit manueller Arbeit oder mit Margenverlust durch falsch angewendete Discounts.

Die gute Nachricht: das Tooling ist 2026 reif. Shopify CLI 3.x ist stabil, Function Runner liefert solide Test-Erfahrung, JavaScript-Support reduziert die Lernkurve dramatisch, und die GraphQL-basierten Schemas machen das Programmiermodell explizit und testbar. Wer einmal eine Function erfolgreich deployed hat, hat kein konzeptionelles Problem mehr — die nächsten Functions kommen schneller.

Wenn Sie Functions evaluieren, anfangen oder von Scripts migrieren wollen, lesen Sie auch unsere verwandten Pillar-Posts: Shopify Hydrogen und Headless Commerce für Frontend-Integration, Shopify Checkout Extensibility für UI-Anpassungen am Checkout, und Shopify Plus B2B Wholesale Portal für die häufigste Functions-Anwendung im B2B. Für ein konkretes Discovery-Gespräch kontaktieren Sie unsere Shopify-Plus-Agentur in Korschenbroich — 20 Minuten von Düsseldorf, deutschsprachig, mit echter Functions-Erfahrung.