> ## Knowledge Base Index
> Fetch the complete knowledge base index at: https://help.pandectes.io/sitemap.xml
> Use this file to discover available pages before exploring further.
> Pure-Markdown content can be obtained by appending a '.md' suffix to the content URLs listed in the sitemap (without the trailing slash).

# So prüfen Sie, ob Pandectes mit der Shopify Customer Privacy API arbeitet

### Überblick

Pandectes GDPR Compliance ist mit der Customer Privacy API von Shopify verbunden. Wählt ein Besucher **Accept**, **Reject** oder eine eigene Auswahl im Präferenzfenster, meldet der Banner diese Entscheidung über die offizielle API an Shopify. Shopify wendet sie anschließend auf die von ihm gesteuerten Bereiche an: Web Pixels, Customer Events, Zielgruppen und Checkout.

Dieser Artikel zeigt, wie Sie in Ihrem eigenen Shop prüfen, ob das Signal ankommt. Er nennt außerdem Prüfungen, die wie Fehler aussehen, aber keine sind.

Wie sich die Integration verhält, lesen Sie unter [Wie die App mit der Shopify Customer Privacy API arbeitet](/en/article/how-the-app-works-with-shopifys-customer-privacy-api-1wqe4u6/). Die Referenz von Shopify selbst ist die [Customer Privacy API](https://shopify.dev/docs/api/customer-privacy).

|| Diese Anleitung ist für einen normalen Shopify-Shop (Online-Store-Theme) geschrieben. Bei einem Headless- oder eigenen Storefront gelten dieselben Prüfungen mit einigen praktischen Einschränkungen. Lesen Sie vorher den Abschnitt zu Headless- und eigenen Storefronts.

### So funktioniert es

Die Aufgabe der App in dieser Integration ist es, die Entscheidung des Besuchers korrekt und unmittelbar an Shopify zu übergeben. Alles Weitere liegt bei Shopify: Web Pixels im Shop und im Checkout laden oder zurückhalten, Vertriebskanäle wie Google & YouTube oder Meta steuern und die Einwilligung auf Customer Events, Zielgruppen und Checkout anwenden.

Das sind Systeme von Shopify, die die Einwilligung aus Shopifys eigener API lesen. Sobald die folgenden Prüfungen zeigen, dass das Signal ankommt, hat die App ihre Aufgabe erfüllt.

`setTrackingConsent()` ist der dokumentierte Weg, über den eine App Shopify mitteilt, wie ein Besucher entschieden hat. Pandectes ruft diese Methode auf. Dieser Aufruf ist die Schnittstelle zwischen App und Shopify.

### Die wichtigsten Punkte

* Prüfen Sie die tatsächliche Entscheidung des Besuchers mit `currentVisitorConsent()` (`''`, `'yes'` oder `'no'`).
* Die `Allowed()`-Methoden vermischen Händlereinstellungen, Standort und Einwilligung. Ein `true` oder `false` allein belegt nicht, dass der Besucher überhaupt entschieden hat.
* `shouldShowBanner()` ist eine Regionsprüfung. Der Wert kann nach einem Accept `true` bleiben.
* Beurteilen Sie diese Integration nicht anhand von Shopify-Cookies, dem `dataLayer` oder Netzwerkanfragen.
* Die erste Prüfung installiert nichts. Das Theme-Snippet und das Test-Pixel sind vorübergehend. Entfernen Sie sie, wenn Sie fertig sind.

| Wenig Zeit? Führen Sie nur die schnelle Konsolenprüfung durch. Wechseln die Werte beim Klick auf Accept von leer auf `'yes'`, schreibt die Integration die Einwilligung nach Shopify.

### Bevor Sie beginnen

Drei Dinge, sonst sind die Ergebnisse irreführend:

1. **Verwenden Sie ein sauberes Browserprofil.** Öffnen Sie ein neues Inkognito- oder privates Fenster oder löschen Sie Cookies und Local Storage für Ihre Domain. Haben Sie bereits eingewilligt, fragt der Banner nicht erneut und Sie sehen nur den Zustand danach.
2. **Testen Sie als Besucher aus einer Region, in der eine Einwilligung erforderlich ist** (zum Beispiel EU/EWR/UK, sofern Ihr Banner so konfiguriert ist). In Regionen, in denen Shopify keine Einwilligung verlangt, ist von vornherein alles erlaubt und der Test belegt nichts.
3. **Stellen Sie sicher, dass das Pandectes-App-Embed in Ihrem Theme aktiviert ist.** Die Integration mit Shopify Customer Privacy ist dauerhaft aktiv und hat keine Einstellung zum Einschalten.

Öffnen Sie die **Entwicklerkonsole** des Browsers:

* **Chrome / Edge:** `F12` drücken, dann den Reiter **Console** öffnen
* **Firefox:** `F12` drücken, dann den Reiter **Console** öffnen
* **Safari:** Das Menü *Entwickeln* unter Einstellungen → Erweitert aktivieren, dann `Option + Command + C`

||| Die erste Prüfung installiert nichts. Die beiden folgenden Snippets sind vorübergehende Diagnosewerkzeuge. Entfernen Sie sie, sobald die Prüfung abgeschlossen ist. Sie sind dafür gedacht, einige Minuten auf Ihrem Bildschirm zu laufen, nicht dauerhaft in einem Live-Shop.

### Was Pandectes an Shopify sendet

Die API von Shopify kennt vier Zwecke. Pandectes ordnet seine Cookie-Kategorien wie folgt zu:

| Pandectes-Kategorie | Shopify-Zweck |
| --- | --- |
| Funktionalität / Preferences | `preferences` |
| Leistung / Analytics | `analytics` |
| Targeting / Marketing | `marketing` |
| Widerspruch gegen Datenverkauf (Do not sell my data) | `sale_of_data` |

Für unbedingt erforderliche Cookies gibt es keine Entsprechung. Sie sind immer erlaubt und nicht Teil dieses Einwilligungsschreibvorgangs.

### Variante 1: Die schnelle Konsolenprüfung

Sie müssen nichts installieren. Ein Befehl, dreimal ausgeführt, genügt.

**Schritt 1.** Öffnen Sie Ihren Shop in einem neuen Inkognito-Fenster. Der Banner erscheint. Klicken Sie nichts an.

**Schritt 2.** Öffnen Sie die Konsole, fügen Sie dies ein und drücken Sie die Eingabetaste:

```javascript
window.Shopify.customerPrivacy.currentVisitorConsent();
```

Sie sollten vier leere Zeichenketten erhalten. So drückt Shopify aus, dass der Besucher noch nicht entschieden hat:

```javascript
{marketing: '', analytics: '', preferences: '', sale_of_data: ''}
```

**Schritt 3.** Klicken Sie im Banner auf **Accept all** und führen Sie denselben Befehl erneut aus:

```javascript
{marketing: 'yes', analytics: 'yes', preferences: 'yes', sale_of_data: ''}
```

**Schritt 4.** Laden Sie die Seite neu und führen Sie den Befehl ein letztes Mal aus. Die Werte müssen erhalten bleiben.

Leer vor der Entscheidung, gefüllt unmittelbar danach, weiterhin gefüllt beim nächsten Seitenaufruf. Das ist der Nachweis. Klicken Sie stattdessen auf **Reject all**, erhalten Sie `'no'` statt `'yes'`. Das ist genauso richtig: Der Besucher wurde gefragt und hat abgelehnt.

Nur `preferences`, `analytics` und `marketing` müssen sich ändern. `sale_of_data` darf leer bleiben. Das ist normal. Siehe den Hinweis unter "Was Sie nicht zur Prüfung heranziehen sollten".

|| Gibt der Befehl einen Fehler zurück, dass `customerPrivacy` nicht definiert ist, ist die API noch nicht vollständig geladen. Warten Sie einen Moment und versuchen Sie es erneut, oder führen Sie zuerst dies aus:

```javascript
window.Shopify.loadFeatures([{name: 'consent-tracking-api', version: '0.1'}], () => {});
```

#### Warum currentVisitorConsent und nicht marketingAllowed

Viele Händler prüfen nur dies:

```javascript
window.Shopify.customerPrivacy.preferencesProcessingAllowed();  // true / false
```

Diese Methode ist nützlich, kann aber nur `true` oder `false` antworten. Die Dokumentation von Shopify erklärt, dass diese Methoden Händlereinstellungen, Standort des Nutzers und Einwilligung zusammenführen.

Ein `false` kann also bedeuten, dass der Besucher abgelehnt hat, oder dass er sich in einer einwilligungspflichtigen Region befindet und noch nicht geantwortet hat. Ein `true` kann bedeuten, dass der Besucher zugestimmt hat, oder dass diese Region keine Einwilligung verlangt. Der boolesche Wert allein sagt nicht, ob der Besucher überhaupt entschieden hat.

`currentVisitorConsent()` gibt die vom Nutzer gewählten Präferenzen zurück und mischt weder Standort noch Händlerkonfiguration hinein:

```javascript
window.Shopify.customerPrivacy.currentVisitorConsent();
// → {marketing: 'yes', analytics: 'no', preferences: 'yes', sale_of_data: ''}
```

| Wert | Bedeutung |
| --- | --- |
| `''` (leere Zeichenkette) | Der Besucher hat die Einwilligung weder erteilt noch verweigert |
| `'yes'` | Der Besucher hat aktiv eingewilligt |
| `'no'` | Der Besucher hat die Einwilligung aktiv verweigert |

Leer vor der Entscheidung des Besuchers, gefüllt danach. Dieser Wechsel ist der Beleg dafür, dass Pandectes die Entscheidung nach Shopify geschrieben hat.

### Variante 2: Der Theme-Test auf dem Bildschirm

Dieses Snippet automatisiert die schnelle Konsolenprüfung. Es gibt den Einwilligungsstatus beim Laden der Seite und erneut bei der Entscheidung des Besuchers in der Konsole aus. Es liest und protokolliert nur, es ändert nichts.

#### Wo Sie das Theme-Snippet einfügen

1. Shopify-Adminbereich → **Online Store → Themes**
2. Klicken Sie bei Ihrem Live-Theme auf **… → Edit code** (sicherer: **duplizieren** Sie das Theme zuerst und testen Sie an der Kopie)
3. Öffnen Sie `layout/theme.liquid`
4. Fügen Sie das Snippet **unmittelbar vor dem schließenden `</body>`-Tag** ein
5. **Speichern**

```html
{% comment %} PANDECTES CONSENT CHECK: temporary, remove after testing {% endcomment %}
<script>
(function () {
  var pandectesTag = '[Pandectes theme check]';

  function pandectesSnapshot(label) {
    var cp = window.Shopify && window.Shopify.customerPrivacy;
    if (!cp) {
      console.warn(pandectesTag, label, 'API not available');
      return;
    }

    var consent = cp.currentVisitorConsent();

    console.log('%c' + pandectesTag + ' ' + label, 'font-weight:bold;color:#0a7');
    console.table({
      'currentVisitorConsent().preferences' : consent.preferences,
      'currentVisitorConsent().analytics'   : consent.analytics,
      'currentVisitorConsent().marketing'   : consent.marketing,
      'currentVisitorConsent().sale_of_data': consent.sale_of_data,
      'preferencesProcessingAllowed()'      : cp.preferencesProcessingAllowed(),
      'analyticsProcessingAllowed()'        : cp.analyticsProcessingAllowed(),
      'marketingAllowed()'                  : cp.marketingAllowed(),
      'saleOfDataAllowed()'                 : cp.saleOfDataAllowed()
    });
  }

  document.addEventListener('visitorConsentCollected', function (event) {
    console.log(pandectesTag, 'visitorConsentCollected →', event.detail);
    pandectesSnapshot('AFTER the visitor decided');
  });

  (function pandectesWaitForShopify(tries) {
    tries = tries || 0;
    if (window.Shopify && window.Shopify.loadFeatures) {
      window.Shopify.loadFeatures(
        [{ name: 'consent-tracking-api', version: '0.1' }],
        function (error) {
          if (error) {
            console.error(pandectesTag, 'could not load the Customer Privacy API', error);
            return;
          }
          pandectesSnapshot('ON PAGE LOAD');
        }
      );
      return;
    }
    if (tries > 100) {
      console.error(pandectesTag, 'window.Shopify.loadFeatures never became available');
      return;
    }
    setTimeout(function () { pandectesWaitForShopify(tries + 1); }, 100);
  })();
})();
</script>
```

#### So führen Sie den Theme-Test durch

Öffnen Sie Ihren Shop in einem **neuen Inkognito-Fenster**, öffnen Sie die **Konsole** und folgen Sie diesen drei Schritten.

**Schritt 1: Bevor Sie den Banner berühren**

Der Banner ist sichtbar. Sie haben nichts angeklickt. Achten Sie auf die Tabelle `ON PAGE LOAD`.

| Was Sie sehen sollten | Bedeutung |
| --- | --- |
| `currentVisitorConsent().preferences` → `""` (leer) | Noch keine Entscheidung getroffen |
| `currentVisitorConsent().analytics` → `""` (leer) | Noch keine Entscheidung getroffen |
| `currentVisitorConsent().marketing` → `""` (leer) | Noch keine Entscheidung getroffen |
| `preferencesProcessingAllowed()` → `false` | Nichts außer dem Notwendigen ist erlaubt |
| `analyticsProcessingAllowed()` → `false` | Nichts außer dem Notwendigen ist erlaubt |
| `marketingAllowed()` → `false` | Nichts außer dem Notwendigen ist erlaubt |

Entscheidend sind die leeren Zeichenketten. Shopify sagt damit, dass dieser Besucher noch nicht entschieden hat.

**Schritt 2: Eine Schaltfläche im Banner anklicken**

Klicken Sie auf **Accept all**. Zwei Dinge müssen sofort in der Konsole erscheinen:

1. Eine Zeile `visitorConsentCollected → {marketingAllowed: true, saleOfDataAllowed: …, analyticsAllowed: true, preferencesAllowed: true}`
2. Eine zweite Tabelle, `AFTER the visitor decided`:

| Was Sie sehen sollten | Bedeutung |
| --- | --- |
| `currentVisitorConsent().preferences` → `"yes"` | Einwilligung aktiv erteilt |
| `currentVisitorConsent().analytics` → `"yes"` | Einwilligung aktiv erteilt |
| `currentVisitorConsent().marketing` → `"yes"` | Einwilligung aktiv erteilt |
| `preferencesProcessingAllowed()` → `true` | Verarbeitung nun zulässig |
| `analyticsProcessingAllowed()` → `true` | Verarbeitung nun zulässig |
| `marketingAllowed()` → `true` | Verarbeitung nun zulässig |

Klicken Sie stattdessen auf **Reject all**, werden die Werte `"no"` und die `Allowed()`-Methoden bleiben `false`. `"no"` ist nicht dasselbe wie `""`: Der Besucher wurde gefragt und hat abgelehnt.

**Schritt 3: Die Seite neu laden**

Laden Sie neu und sehen Sie sich die neue Tabelle `ON PAGE LOAD` an. Die Werte aus Schritt 2 müssen weiterhin vorhanden sein. Das belegt, dass Shopify die Entscheidung gespeichert hat und sie auf folgenden Seiten zurückgibt.

Verhalten sich die Schritte 1, 2 und 3 wie beschrieben, schreibt die Integration die Einwilligung nach Shopify.

||| Entfernen Sie das Snippet nun aus `layout/theme.liquid` und speichern Sie. Lassen Sie es nicht in einem Live-Theme stehen. Es ist ein Testwerkzeug, kein Bestandteil Ihres Shops.

### Variante 3: Der Shopify-Pixel-Test

Das Theme-Snippet belegt, dass Shopify die Entscheidung gespeichert hat. Dieses zweite Snippet belegt, dass die Entscheidung auch die Web Pixels von Shopify erreicht (Google & YouTube, Meta, Klaviyo und jedes Custom Pixel).

Pixel laufen in einer Sandbox, getrennt von Ihrem Theme. Shopify übergibt ihnen den Einwilligungsstatus direkt. Das Snippet erstellt ein kleines Test-Pixel, das meldet, was ihm übergeben wurde.

#### Wo Sie das Pixel-Snippet einfügen

1. Shopify-Adminbereich → **Settings → Customer events**
2. Klicken Sie auf **Add custom pixel** und benennen Sie es `Pandectes consent check`
3. Setzen Sie unter **Customer privacy** die **Permission** auf **Not required**, damit dieses Test-Pixel immer läuft und auch den Zustand davor melden kann
4. Fügen Sie den Code ein, klicken Sie auf **Save** und dann auf **Connect**

```javascript
// Pandectes consent check. TEMPORARY test pixel. Disconnect and delete when finished.
const pandectesTag = '[Pandectes pixel check]';

function pandectesLog(label, cp) {
  console.log(pandectesTag + ' ' + label, {
    preferencesProcessingAllowed: cp.preferencesProcessingAllowed,
    analyticsProcessingAllowed:   cp.analyticsProcessingAllowed,
    marketingAllowed:             cp.marketingAllowed,
    saleOfDataAllowed:            cp.saleOfDataAllowed
  });
}

let pandectesConsentState = init.customerPrivacy;
pandectesLog('state when the pixel started', pandectesConsentState);

api.customerPrivacy.subscribe('visitorConsentCollected', (event) => {
  pandectesConsentState = event.customerPrivacy;
  pandectesLog('state after the visitor decided', pandectesConsentState);
});

analytics.subscribe('page_viewed', (event) => {
  pandectesLog('state at page_viewed', pandectesConsentState);
});
```

|| Warum die langen Variablennamen? Die Pixel-Sandbox definiert bereits globale Namen wie `status` und `name`, sodass ein einfaches `let status = …` als erneute Definition gemeldet wird. Jeder Name in beiden Snippets beginnt daher mit `pandectes`. Lassen Sie sie unverändert.

#### Was Sie im Pixel-Test sehen sollten

Wieder in einem frischen Inkognito-Fenster mit geöffneter Konsole:

| Zeitpunkt | Erwartete Ausgabe |
| --- | --- |
| Seite lädt, Banner sichtbar, nichts angeklickt | `state when the pixel started` → `preferencesProcessingAllowed`, `analyticsProcessingAllowed` und `marketingAllowed` alle `false` |
| Sie klicken auf **Accept all** | `state after the visitor decided` → dieselben drei sind nun `true` |
| Sie laden die Seite neu | `state when the pixel started` → die drei sind weiterhin `true` |

`saleOfDataAllowed` gehört nicht zu dieser Prüfung. Außerhalb von Regionen mit Widerspruchsrecht gegen den Datenverkauf kann der Wert von Anfang an `true` sein. Das ist zu erwarten.

|| Diese Zeilen stammen aus der Pixel-Sandbox von Shopify, in Chrome erscheinen sie daher mit der Quelle `web-pixels…sandbox`. Sehen Sie sie nicht, stellen Sie sicher, dass der Konsolenfilter nicht auf "selected context only" steht und dass kein Filtertext eingetragen ist.

Wechseln diese drei Werte beim Klick auf Accept von `false` auf `true`, übergibt Shopify den Einwilligungsstatus an die Pixel.

||| Trennen und löschen Sie dieses Test-Pixel, sobald Sie fertig sind. Es ist so eingestellt, dass es ohne Einwilligung läuft, und darf daher nicht in einem Live-Shop verbleiben.

### Sobald das Signal ankommt, ist der Rest Sache von Shopify

Die Web Pixels von Shopify laufen in gekapselten, domainfremden iFrames, die Shopify kontrolliert. Keine Einwilligungs-App kann sie starten, stoppen oder verändern, was sie senden. Das Einwilligungssignal ist der einzige vorhandene Hebel.

Die Prüfung teilt sich in zwei Fragen:

1. **Kommt das Signal an?** Das beantworten die obigen Prüfungen. Dafür ist Pandectes verantwortlich.
2. **Handelt Shopify entsprechend dem Signal?** Das ist eine Frage an Shopify, beantwortet in den Shopify-Einstellungen und, falls nötig, vom Shopify-Support.

Wechselt `currentVisitorConsent()` beim Klick des Besuchers von leer auf `'yes'` oder `'no'`, hat die App ihre Aufgabe erfüllt. Verhält sich danach ein Pixel oder ein Kanal anders als erwartet, suchen Sie auf der Seite von Shopify:

| Wer | Macht was |
| --- | --- |
| **Pandectes** | Zeigt den Banner, erfasst die Entscheidung, schreibt sie über `setTrackingConsent()` nach Shopify |
| **Shopify** | Entscheidet, welche Web Pixels im Shop und im Checkout laden, steuert Vertriebskanäle und wendet die Einwilligung auf Customer Events, Zielgruppen und Checkout an |

* **Settings → Customer events:** Jedes Pixel hat eine eigene Einstellung unter **Customer privacy → Permission**. Ein Pixel mit *Not required* läuft unabhängig von der Einwilligung, weil der Shop Shopify genau das mitgeteilt hat.
* **Die Konfiguration des jeweiligen Vertriebskanals.** Der Kanal Google & YouTube etwa erzeugt aus der Shopify-API sein eigenes Google-Einwilligungssignal. Diese Übersetzung ist Shopify-Code.
* **Der Shopify-Support** für alles, was bleibt, nachdem die API den richtigen Wert hält.

Stellen Sie es sich wie einen Lichtschalter vor: Pandectes ist der Schalter, Shopify ist die Verkabelung und die Lampen. Wenn Sie geprüft haben, dass der Schalter umlegt, ist eine Lampe, die weiterbrennt, eine Frage der Verkabelung.

### Headless- und eigene Storefronts

Dieselbe API, dieselben Methoden und dieselbe Bedeutung von `''`, `'yes'` und `'no'` gelten auch bei einem Headless-Shop. Die schnelle Konsolenprüfung funktioniert unverändert. Anders ist nur, wie Sie die beiden Snippets ausführen, plus eine zusätzliche Einstellung.

#### Sie haben keine theme.liquid

Die Seiten Ihres Storefronts sind Ihr eigener Code, es gibt also keinen Ort, an dem Sie das Theme-Snippet wie beschrieben einfügen könnten. Zwei Möglichkeiten:

**Variante A: in der Browser-Konsole einfügen (nichts zu deployen).**
Kopieren Sie alles zwischen `<script>` und `</script>` aus dem Theme-Snippet, öffnen Sie Ihren Shop in einem sauberen Inkognito-Fenster mit sichtbarem Banner, fügen Sie es in die Konsole ein und drücken Sie die Eingabetaste. Sie erhalten sofort die Tabelle `ON PAGE LOAD` und beim Klick auf den Banner die Tabelle `AFTER the visitor decided`.

|| Konsolen-Code verschwindet beim Neuladen der Seite. Für den Schritt mit dem Neuladen laden Sie zuerst neu und fügen das Snippet dann erneut ein, um die gespeicherten Werte auszulesen.

**Variante B: in Ihr eigenes Root-Layout einfügen.**
Fügen Sie denselben `<script>`-Block dort ein, wo er auf jeder Seite gerendert wird: im Root-Layout von Hydrogen oder Next.js, in der `index.html` einer Vite- oder React-App und so weiter. Entfernen Sie ihn nach dem Test.

#### Snippet 2 läuft im Checkout, nicht in Ihrem Storefront

Die Web Pixels von Shopify laufen nicht auf Seiten, die Sie selbst hosten. Sie laufen auf Bereichen, die Shopify gehören: im **Checkout** und auf der **Bestellstatus- bzw. Dankeseite**. Um die Ausgabe des Pixel-Snippets zu sehen, legen Sie ein Produkt in den Warenkorb und gehen Sie bei geöffneter Konsole zum Checkout. Die im Storefront getroffene Entscheidung sollte beim Start des Pixels bereits vorliegen.

#### Eine zusätzliche Einstellung: Ihre beiden Domains

Bei einem Headless-Shop benötigt Shopify die Domains von Storefront und Checkout, bevor es eine Einwilligung speichern kann. Die Dokumentation von Shopify verlangt für eigene Storefronts diese Werte:

* `headlessStorefront`
* `storefrontRootDomain`
* `checkoutRootDomain`
* `storefrontAccessToken`

Pandectes sendet sie bei jedem Einwilligungsschreibvorgang aus Ihrer App-Konfiguration mit. Fehlen sie im Pandectes-Adminbereich oder sind sie falsch, kann der Schreibvorgang nach Shopify nicht gelingen und `currentVisitorConsent()` gibt weiterhin leere Zeichenketten zurück. Scheitert Ihr Headless-Test, prüfen Sie zuerst diese Werte.

Die Domains müssen außerdem zusammenpassen: Storefront- und Checkout-Domain müssen zum selben Shop gehören, damit der Checkout genau die Entscheidung sieht, die im Storefront getroffen wurde.

### Was Sie nicht zur Prüfung heranziehen sollten

Diese Prüfungen messen entweder etwas anderes oder gehören nicht zur dokumentierten API.

#### Erwarten Sie nicht, dass shouldShowBanner nach der Einwilligung false wird

Viele Händler erwarten, dass `shouldShowBanner()` vor der Einwilligung `true` und danach `false` ist, und melden einen Fehler, wenn der Wert `true` bleibt.

Es ist keine Einwilligungsmethode. Shopify dokumentiert sie als Angabe, ob sich der aktuelle Kunde in einer Region befindet, für die ein Cookie-Banner vorgesehen ist. Ein deutscher Besucher ist auch nach einem Accept weiterhin in Deutschland, die Antwort bleibt also `true`. Ein `shouldShowBanner()`, das nach der Einwilligung `true` bleibt, ist zu erwarten.

Dasselbe gilt für `saleOfDataRegion()`, das angibt, ob sich der aktuelle Kunde in einer Region mit Widerspruchsrecht gegen den Datenverkauf befindet. Auch das ist eine Regionsprüfung.

#### Verlassen Sie sich nicht auf getTrackingConsent, getRegulation oder isRegulationEnforced

Diese tauchen in der Dokumentation der Customer Privacy API von Shopify nicht auf. Es sind interne Werte, die Shopify ändern oder entfernen kann. Insbesondere ist ein `getTrackingConsent()`, das vor der Einwilligung `"yes"` zurückgibt, kein Beleg dafür, dass etwas erteilt wurde.

#### Verwenden Sie nicht userCanBeTracked oder userDataCanBeSold

Diese existieren, aber Shopify führt sie in der Legacy-Dokumentation und rät davon ab, neue Integrationen damit zu beginnen. Nutzen Sie stattdessen `currentVisitorConsent()` und die vier `Allowed()`-Methoden.

#### Suchen Sie nicht nach einem _tracking_consent-Cookie in document.cookie

Die Dokumentation von Shopify rät davon ab, Shopify-Cookies direkt zu lesen oder zu verändern. Shopify sichert nicht zu, dass sein Einwilligungs-Cookie aus JavaScript lesbar ist, einen bestimmten Namen trägt oder in einer bestimmten Version existiert. Es nicht zu finden, beweist nichts.

#### Beurteilen Sie die App nicht danach, ob ein Pixel oder eine Netzwerkanfrage weiterhin ausgelöst wird

Eine Anfrage, die den Browser verlässt, ist ein Ergebnis von Shopify. Ist das Einwilligungssignal korrekt und ein Shopify-Pixel läuft dennoch, wurde Shopify das Richtige mitgeteilt und hat sich entschieden, das Pixel auszuführen, meist weil dessen **Permission** unter **Settings → Customer events** auf *Not required* steht oder weil der Vertriebskanal so konfiguriert ist, dass er ohne Einwilligung läuft. Korrigieren Sie es dort.

#### Vergleichen Sie keine Einträge in window.dataLayer

Der `dataLayer` gehört zum Google Consent Mode, einem von der Shopify Customer Privacy API getrennten System. Pandectes schreibt in beide, und der Kanal Google & YouTube von Shopify schreibt zusätzlich eigene Einträge. Mehrere `consent`-Einträge dort sind normal und belegen nichts über die Shopify-API.

#### Erwarten Sie nicht bei jedem Seitenaufruf einen setTrackingConsent-Aufruf

Pandectes schreibt nur dann nach Shopify, wenn sich der Status ändert. Hält Shopify bereits dieselbe Entscheidung, sendet die App sie nicht erneut. Bei einem Neuladen nach der Einwilligung sehen Sie also die gespeicherten Werte, aber keinen neuen Schreibvorgang.

#### Machen Sie sich keine Sorgen, wenn sale_of_data leer bleibt

`sale_of_data` ist dort relevant, wo ein Widerspruchsrecht gegen den Datenverkauf gilt (vor allem in bestimmten US-Bundesstaaten). Befindet sich der Besucher nicht in einer solchen Region oder ist *Do not sell my data* in Pandectes nicht aktiviert, sendet Pandectes dieses Feld nicht mit. Ein leeres `sale_of_data` bei einem EU-Besucher ist zu erwarten.

### Kurzübersicht: die dokumentierten Methoden

| Methode | Rückgabe | Was sie aussagt |
| --- | --- | --- |
| `currentVisitorConsent()` | `{preferences, analytics, marketing, sale_of_data}`, jeweils `'yes'` / `'no'` / `''` | Die Entscheidung des Besuchers selbst. Diese sollten Sie verwenden. |
| `preferencesProcessingAllowed()` | `true` / `false` | Ob die Verarbeitung von Präferenzen erlaubt ist (Region, Einstellungen und Einwilligung kombiniert) |
| `analyticsProcessingAllowed()` | `true` / `false` | Ob die Analyseverarbeitung erlaubt ist (Region, Einstellungen und Einwilligung kombiniert) |
| `marketingAllowed()` | `true` / `false` | Ob Marketing erlaubt ist (Region, Einstellungen und Einwilligung kombiniert) |
| `saleOfDataAllowed()` | `true` / `false` | Ob die Weitergabe von Daten an Dritte erlaubt ist |
| `shouldShowBanner()` | `true` / `false` | Nur Region: ob in dieser Region ein Banner gezeigt werden soll |
| `saleOfDataRegion()` | `true` / `false` | Nur Region: ob hier ein Widerspruchsrecht gegen den Datenverkauf gilt |
| `getRegion()` | z. B. `"DEHH"` | Der Standort des Besuchers im Format ISO 3166-2 |
| Ereignis `visitorConsentCollected` | `{marketingAllowed, saleOfDataAllowed, analyticsAllowed, preferencesAllowed}` | Wird bei jeder Änderung der Einwilligung ausgelöst |

### Wenn der Test tatsächlich fehlschlägt

Klären Sie zuerst, welche Hälfte fehlgeschlagen ist.

**Ist das Signal korrekt**, wechselt `currentVisitorConsent()` beim Klick also von leer auf `'yes'` oder `'no'`, dann schreibt die App die Einwilligung. Alles Weitere liegt bei Shopify. Prüfen Sie die **Permission** jedes Pixels unter **Settings → Customer events**, danach die Konfiguration der Vertriebskanäle und schließlich den Shopify-Support.

**Fehlt das Signal**, gibt `currentVisitorConsent()` also auch nach einem Klick im Banner weiterhin leere Zeichenketten zurück, prüfen Sie in dieser Reihenfolge:

1. Das Pandectes-App-Embed ist in dem Theme aktiviert, das Sie testen (Online Store → Themes → Customize → App embeds).
2. Sie testen das Live-Theme und nicht die Vorschau eines anderen.
3. Es ist keine weitere Einwilligungs-App installiert. Zwei Apps, die in dieselbe API schreiben, geraten in Konflikt. Nur eine darf aktiv sein.
4. Sie befinden sich nicht in einer Admin-Vorschau, die sich anders verhalten kann als ein echter Besuch.
5. Nur bei Headless-Shops: Storefront-Domain, Checkout-Domain und Storefront-Access-Token sind im Pandectes-Adminbereich korrekt eingetragen.

Es schlägt weiterhin fehl? Wenden Sie sich an **support@pandectes.io** und geben Sie an:

* die Domain Ihres Shops (bei Headless zusätzlich Storefront- und Checkout-Domain)
* das Besucherland, aus dem Sie getestet haben
* die Konsolenausgabe der schnellen Konsolenprüfung oder des Theme-Snippets zu allen drei Zeitpunkten (vor dem Klick, nach dem Klick, nach dem Neuladen)

### Aufräumen, wenn Sie fertig sind

Überspringen Sie diesen Schritt nicht. Die schnelle Konsolenprüfung installiert nichts. Beide Snippets sind vorübergehend.

1. **Theme-Snippet:** Öffnen Sie `layout/theme.liquid`, löschen Sie den Block, der mit `{% comment %} PANDECTES CONSENT CHECK` beginnt, und **speichern** Sie. Haben Sie an einem duplizierten Theme getestet, können Sie diese Kopie löschen.
2. **Pixel-Snippet:** Gehen Sie zu **Settings → Customer events**, öffnen Sie `Pandectes consent check`, klicken Sie auf **Disconnect** und anschließend auf **Delete**.
3. **Headless-Shops:** Haben Sie das Skript in Ihr eigenes Layout eingefügt, entfernen Sie es und deployen Sie erneut. Haben Sie die Browser-Konsole genutzt, genügt es, den Tab zu schließen.

Warum das wichtig ist:

* Das Theme-Snippet gibt Einwilligungsdetails in der Konsole jedes Besuchers auf jeder Seite aus, bis Sie es entfernen.
* Das Test-Pixel ist mit **Permission: Not required** konfiguriert und läuft daher absichtlich vor der Einwilligung. Für einen kurzen Test ist das richtig, für einen Live-Shop falsch.
* Beide erzeugen bei jedem Seitenaufruf zusätzliche Arbeit, die nach abgeschlossener Prüfung keinen Nutzen mehr bringt.

Das Entfernen ändert nichts an der Integration. Die App meldet Shopify die Einwilligung weiterhin wie zuvor.

### Zusammenfassung

Prüfen Sie diese Integration mit `currentVisitorConsent()`. Leere Zeichenketten vor der Entscheidung, `'yes'` oder `'no'` unmittelbar danach und dieselben Werte nach dem Neuladen bedeuten, dass Pandectes die Entscheidung nach Shopify geschrieben hat. Das Laden von Pixeln, die Vertriebskanäle und das Verhalten im Checkout liegen danach in der Verantwortung von Shopify. Entfernen Sie alle vorübergehenden Theme- oder Pixel-Snippets, wenn Sie fertig sind.