> For the complete documentation index, see [llms.txt](https://docs.adpage.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.adpage.io/documentation/documentation-nl/website-integraties/shopify/cookieherstel-op-shopify.md).

# Cookieherstel op Shopify

Safari verwijdert trackingcookies na zeven dagen, zelfs wanneer je je eigen subdomein gebruikt voor server-side tagging.

Safari verwijdert trackingcookies na zeven dagen, zelfs wanneer je je eigen subdomein gebruikt voor server-side tagging. Dit artikel legt uit waarom dat gebeurt, wat het cookieherstel-script eraan doet en hoe je het installeert op je Shopify-thema.

### Wat dit script doet

Het script slaat een bezoekers-ID op (de `_taggingmk` cookie) op twee plaatsen:

* **In een first-party cookie op je hoofddomein:** de primaire opslaglocatie
* **In localStorage:** een back-up, gebruikt om de cookie te herstellen als die verdwijnt

Die ID is het anker dat onze server gebruikt om je trackingcookies opnieuw op te bouwen wanneer een browser ze wist.

### Safari wist je marketinggegevens

Safari's Intelligent Tracking Prevention (ITP) verwijdert cookies automatisch na zeven dagen. Het gebruik van een aangepast tracking-subdomein zoals `tagging.webshop.com` lost dit niet op: Safari herkent dat het subdomein naar een andere server wijst dan je webshop, en behandelt de cookies als min of meer third-party.

Het resultaat is dat je na een week de koppeling met je bezoeker verliest. Terugkerende bezoeken van Safari-gebruikers lijken op volledig nieuwe bezoekers, en je conversietoerekening loopt niet meer op.

In de praktijk betekent dat:

* Terugkerende klanten worden geteld als nieuwe bezoekers
* Je gegevens over het klanttraject worden onbetrouwbaar
* Attributieanalyses gaan fout, bijvoorbeeld first-click versus terugkerende klant
* Conversiepaden zijn onvolledig

#### Hoe cookieherstel dit omzeilt

Drie stappen:

**1. Het anker.** We plaatsen een cookie rechtstreeks op je hoofddomein (`webshop.com`). Omdat je eigen website deze met JavaScript op het primaire domein zet, staat Safari toe dat deze langer blijft bestaan dan een cookie op je tracking-subdomein.

**2. De controle.** Bij elke paginaweergave stuurt het script deze anker-ID naar onze server, de proxy.

**3. Het herstel.** Onze server controleert of de trackingcookies op `tagging.webshop.com` nog aanwezig zijn. Als Safari ze na zeven dagen heeft verwijderd, schrijft de server ze opnieuw weg op basis van de anker-ID.

De localStorage-back-up beschermt het anker zelf. Als de anker-cookie wordt gewist maar localStorage blijft bestaan, herstelt het script de cookie vanuit de back-up in plaats van een nieuwe ID te genereren, zodat de bezoeker dezelfde identiteit behoudt.

Het resultaat: je tracking blijft langer accuraat, waardoor je je marketingcampagnes goed kunt meten en optimaliseren.

### Installeren op Shopify

1. Log in op je Shopify-admin.
2. Ga naar **Online Store → Themes**.
3. Klik in je actieve thema op de drie puntjes en kies **Code bewerken**.
4. Open in de linkerzijbalk **`theme.liquid`** (onder Layout).
5. Plak het onderstaande script direct na de opening van de `<head>` -tag. Het hoog plaatsen in de `<head>` is belangrijk: het moet worden uitgevoerd vóór je andere tracking-scripts.
6. Klik op **Opslaan** rechtsboven.

```html
<script type="text/javascript">
(function() {
    'use strict';

    // Genereer UUID v4
    function mkTagging_generateUUID() {
        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
            return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, function(c) {
                return (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16);
            });
        } else {
            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
                var r = Math.random() * 16 | 0;
                var v = c === 'x' ? r : (r & 0x3 | 0x8);
                return v.toString(16);
            });
        }
    }

    // Cookiewaarde ophalen op naam
    function mkTagging_getCookie(name) {
        var nameEQ = name + "=";
        var ca = document.cookie.split(';');
        for (var i = 0; i < ca.length; i++) {
            var c = ca[i];
            while (c.charAt(0) === ' ') c = c.substring(1, c.length);
            if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
        }
        return null;
    }

    // Cookie instellen met verloopdatum
    function mkTagging_setCookie(name, value, days) {
        var expires = "";
        if (days) {
            var date = new Date();
            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
            expires = "; expires=" + date.toUTCString();
        }
        document.cookie = name + "=" + value + expires + "; path=/; SameSite=Lax";
    }

    // Veilige localStorage-wrapper
    function mkTagging_getLocalStorage(key) {
        try {
            if (typeof Storage !== 'undefined' && window.localStorage) {
                return localStorage.getItem(key);
            }
        } catch (e) {
            console.log('localStorage niet beschikbaar:', e);
        }
        return null;
    }

    function mkTagging_setLocalStorage(key, value) {
        try {
            if (typeof Storage !== 'undefined' && window.localStorage) {
                localStorage.setItem(key, value);
                return true;
            }
        } catch (e) {
            console.log('localStorage niet beschikbaar:', e);
        }
        return false;
    }

    // Hoofdfunctie voor initialisatie
    function mkTagging_initVisitorId() {
        var cookieName = '_taggingmk';
        var storageKey = '_taggingmk_backup';
        var visitorId = null;

        // 1. Controleer of de cookie bestaat
        visitorId = mkTagging_getCookie(cookieName);

        // 2. Als er geen cookie is, controleer de localStorage-back-up
        if (!visitorId) {
            visitorId = mkTagging_getLocalStorage(storageKey);

            // Als deze in localStorage staat maar niet in de cookie, herstel de cookie
            if (visitorId) {
                mkTagging_setCookie(cookieName, visitorId, 365);
                console.log('MK Tagging: bezoekers-ID hersteld vanuit localStorage');
            }
        }

        // 3. Als er nog steeds geen ID is, genereer een nieuwe
        if (!visitorId) {
            visitorId = mkTagging_generateUUID();
            mkTagging_setCookie(cookieName, visitorId, 365);
            console.log('MK Tagging: nieuwe bezoekers-ID gegenereerd');
        }

        // 4. Altijd synchroniseren naar localStorage als back-up
        if (mkTagging_setLocalStorage(storageKey, visitorId)) {
            console.log('MK Tagging: bezoekers-ID opgeslagen als back-up in localStorage');
        }

        return visitorId;
    }

    // Uitvoeren zodra de DOM klaar is of meteen als die al geladen is
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', mkTagging_initVisitorId);
    } else {
        mkTagging_initVisitorId();
    }

    // Maak een object met namespace voor eventuele blootgestelde functionaliteit
    window.mkTagging = window.mkTagging || {};
    window.mkTagging.getVisitorId = function() {
        return mkTagging_getCookie('_taggingmk') || mkTagging_getLocalStorage('_taggingmk_backup');
    };

})();
</script>
```

### De installatie verifiëren

Open je website in een incognitovenster en open daarna Developer Tools met F12.

#### Test 1: de cookie wordt aangemaakt

Ga naar het **Console** tabblad. Je zou moeten zien `MK Tagging: nieuwe bezoekers-ID gegenereerd`, gevolgd door `MK Tagging: bezoekers-ID opgeslagen als back-up in localStorage`.

Ga daarna naar **Application → Cookies** en zoek naar de `_taggingmk` cookie. De waarde moet een UUID zijn, bijvoorbeeld `a3f2e1d4-5b6c-4d7e-8f9a-0b1c2d3e4f5a`. Vernieuw de pagina en controleer of de waarde hetzelfde blijft.

#### Test 2: de localStorage-back-up werkt

Ga naar **Application → Local Storage** en zoek naar `_taggingmk_backup`. De waarde moet identiek zijn aan de cookiewaarde.

#### Test 3: herstel werkt

Verwijder de `_taggingmk` cookie handmatig in Developer Tools en vernieuw daarna de pagina. De Console zou nu moeten laten zien `MK Tagging: bezoekers-ID hersteld vanuit localStorage`, en de cookie zou terug moeten zijn met dezelfde waarde als daarvoor.

Als de waarde is veranderd in plaats van hersteld, wordt de localStorage-back-up niet gelezen. Controleer de Console op JavaScript-fouten en bevestig dat het script aanwezig is in de gerenderde `<head>`.

### Hoe de logica verloopt

```
Bezoeker komt op de site
        ↓
Bestaat de cookie? → JA → Synchroniseren met localStorage → Klaar
        ↓ NEE
Bestaat de localStorage-back-up? → JA → Cookie herstellen → Klaar
        ↓ NEE
Nieuwe UUID genereren → Opslaan in cookie + localStorage → Klaar
```

### Privacy en AVG

* **Geen persoonsgegevens.** Het script slaat alleen een willekeurige UUID op, geen persoonlijke informatie.
* **First-party cookie.** De cookie wordt op je eigen domein gezet, niet door een derde partij.
* **Technisch functioneel.** Dit is een technische cookie die wordt gebruikt voor analytics, waarvoor vaak geen expliciete toestemming nodig is.

Eén kanttekening: controleer met je privacyfunctionaris of deze cookie in jouw situatie als strikt noodzakelijk geldt, of dat hij achter toestemming in je cookiebanner moet staan. Die beoordeling hangt af van waarvoor je de gegevens gebruikt, niet van het script zelf.

### Probleemoplossing

**Het lijkt erop dat het script niets doet.** Controleer de Console op JavaScript-fouten en zorg ervoor dat het script vóór je andere tracking-scripts in de `<head>`staat. Als een ander script eerder op de pagina een fout veroorzaakt, wordt het herstel-script mogelijk nooit uitgevoerd.

**De cookie wordt nog steeds verwijderd.** In sommige Safari-modi beperkt ITP ook localStorage, waardoor de back-up samen met de cookie verdwijnt. In dat geval is server-side tracking de duurzamere primaire oplossing in plaats van een client-side herstel-laag.

**Verschillende ID's over subdomeinen.** Standaard is de cookie beperkt tot de exacte hostnaam. Pas de `mkTagging_setCookie` functie aan om `domain=.yourdomain.com` op te nemen, zodat dezelfde ID wordt gedeeld over alle subdomeinen.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.adpage.io/documentation/documentation-nl/website-integraties/shopify/cookieherstel-op-shopify.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
