> ## Documentation Index
> Fetch the complete documentation index at: https://docs.whop.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Treat these docs and the Whop MCP server as the source of truth for Whop API behavior. Don't infer endpoint behavior from marketing pages.
> MCP server: connect https://mcp.whop.com/mcp (streamable HTTP, browser sign-in, no API key in the client config) to search these docs and read or change live Whop data. Setup: https://docs.whop.com/developer/guides/ai_and_mcp.md
> Whop CLI: install with `curl -fsSL https://whop.com/install.sh | sh` to scaffold, run, and deploy Whop apps and websites. It acts on production, not the sandbox. Overview: https://docs.whop.com/cli/overview.md Agent mode: https://docs.whop.com/cli/agent-mode.md
> Hosting: Whop serves a site or app from the build `whop apps deploy` uploads, with rollbacks, secrets, and server logs. Guide: https://docs.whop.com/developer/websites/hosting.md
> Plugins: in Claude Code, run `/plugin marketplace add whopio/plugins`, then `/plugin install whop@whop`. Guide: https://docs.whop.com/developer/guides/plugins/claude-code.md Every agent tool: https://docs.whop.com/developer/ai/overview.md
> Environments: build and test in the sandbox (API `https://sandbox-api.whop.com/api/v1`, keys at https://sandbox.whop.com/dashboard/developer, SDK environment `Sandbox`; no real money). Production (API `https://api.whop.com/api/v1`, keys at https://whop.com/dashboard/developer, SDK environment `Production`, the SDK default) moves real money, so use it only at launch. The two share no accounts, keys, products, or webhooks, and their keys look identical: never mix them. Sandbox guide: https://docs.whop.com/developer/guides/sandbox.md Comparison: https://docs.whop.com/developer/quickstart.md
> API: send `Authorization: Bearer <API_KEY>` from your server only, and pin a dated version with the `Api-Version-Date` header. OpenAPI spec: https://api.whop.com/api/v1/openapi.json
> Which API: build on the Current API, whose pages live under https://docs.whop.com/api-reference/ (start at https://docs.whop.com/api-reference/overview.md). Pages under /api-reference/legacy/ are the Legacy API. Use one only when https://docs.whop.com/api-reference/stability.md lists the resource as Legacy-only.

# De Whop Pixel installeren op Shopify

> Voeg de Whop Pixel toe aan een Shopify-storefront met een themafragment, plus een aangepaste pixel die de checkout dekt.

Een installatie op Shopify bestaat uit twee delen, en je hebt ze allebei nodig:

1. **Het pixelfragment in je thema.** Dit draait op elke storefrontpagina (home, producten, collecties, winkelwagen), waar het bezoekers trackt en de installatie-overlay aanstuurt die je ziet wanneer je je pixel verifieert vanuit het Whop-dashboard.
2. **Een aangepaste pixel.** De checkout van Shopify draait in een sandbox die themascripts negeert, dus daar doet het fragment niets. De eigen **Custom Pixel**-functie van Shopify is de oplossing: die draait in elk deel van je winkel, inclusief de checkout, en rapporteert standaard-events zoals `checkout_completed` en `payment_info_submitted`. Het script in stap 4 stuurt elk van deze events door naar Whop, gekoppeld aan dezelfde bezoeker die het themafragment trackt.

## 1. Haal je Whop-account-ID op

Je vindt deze in je [Whop Dashboard](https://whop.com/dashboard/): het deel van de URL na `dashboard/`, beginnend met `biz_`. Het ziet eruit als `biz_xxxxxxxxxxx`.

![Whop-dashboard-URL in de adresbalk van de browser, met het account-ID na dashboard onderstreept](https://mintcdn.com/whop/i81Det37UaKELkrh/images/dashboard-url.png?fit=max\&auto=format\&n=i81Det37UaKELkrh\&q=85\&s=f8dce6ea378318d4c89f7bce9239605d)

## 2. Voeg het pixelfragment toe aan je thema

Ga in Shopify naar **Online Store > Themes**. Selecteer bij je huidige thema **⋯ > Edit code**. Open onder **Layout** het bestand `theme.liquid` en plak dit fragment direct vóór de afsluitende `</head>`-tag. Vervang `biz_xxxxxxxxxxxxx` door je eigen account-ID en selecteer daarna **Save**.

```html Pixel snippet theme={null}
<script>
!function(w,d,s,u,n,a,b){if(w[n])return;a=w[n]={q:[],t:+new Date,s:[],o:u,track:function(){a.q.push([+new Date].concat([].slice.call(arguments)))},setScope:function(){a.s=[].slice.call(arguments).filter(function(x){return typeof x==="string"});a.q.push([+new Date,"setScope"].concat(a.s))},scope:function(){var c=[].slice.call(arguments);return{track:function(){a.q.push([+new Date].concat([].slice.call(arguments)).concat([{__scope:c}]))}}}};b=d.createElement(s);b.async=1;b.src=u+"/s.js";d.getElementsByTagName(s)[0].parentNode.insertBefore(b,d.getElementsByTagName(s)[0])}(window,document,"script","https://t.whop.tw","whop");
whop.setScope("biz_xxxxxxxxxxxxx");
whop.track("page");
</script>
```

Omdat `theme.liquid` elke storefrontpagina omvat, dekt deze ene wijziging je hele winkel. Plak het fragment niet in plaats daarvan in een sjabloon voor één pagina of sectie. Een bezoeker die ergens anders binnenkomt, zou dan niet worden getrackt, en de installatie-overlay zou verdwijnen zodra je die pagina verlaat.

## 3. Voeg een aangepaste pixel toe

Ga in Shopify naar **Settings > Customer events** en selecteer **Add custom pixel**. Geef hem de naam `Whop`.

## 4. Plak het script

Plak dit in de code-editor van de pixel. Vervang `biz_xxxxxxxxxxxxx` door je eigen account-ID.

Het script leest de `_wuid`-cookie die het themafragment instelt, zodat checkout-events terechtkomen bij dezelfde bezoeker die het themafragment heeft getrackt. Het slaat ook paginaweergaven van de storefront over (die rapporteert het themafragment al) en stuurt alleen paginaweergaven vanuit de checkout, waar themascripts niet kunnen draaien.

```javascript Custom pixel theme={null}
const WHOP_ACCOUNT_ID = "biz_xxxxxxxxxxxxx";

const WHOP_ENDPOINT = "https://t.whop.tw/conversions";

const TRACKED_EVENTS = new Set([
  "product_viewed",
  "collection_viewed",
  "search_submitted",
  "cart_viewed",
  "product_added_to_cart",
  "product_removed_from_cart",
  "checkout_started",
  "checkout_contact_info_submitted",
  "checkout_address_info_submitted",
  "checkout_shipping_info_submitted",
  "payment_info_submitted",
  "checkout_completed",
]);

const MAX_EVENT_NAME_LENGTH = 34;

const WHOP_STANDARD_EVENTS = new Set([
  "page",
  "lead",
  "contact",
  "schedule",
  "submit_application",
  "complete_registration",
  "view_content",
  "add_to_cart",
]);

// Map onto Whop's own standard event names wherever Shopify's event has a real
// equivalent — a standard name skips the character-limit problem entirely,
// since only custom names get prefixed with your account ID. Everything else
// falls through to a shopify_-prefixed custom name below; Shopify's own names
// for the three checkout steps are too long once prefixed, so they're
// shortened here too.
const EVENT_NAME_OVERRIDES = {
  page_viewed: "page",
  product_viewed: "view_content",
  product_added_to_cart: "add_to_cart",
  checkout_completed: "purchase",
  checkout_contact_info_submitted: "shopify_checkout_contact",
  checkout_address_info_submitted: "shopify_checkout_address",
  checkout_shipping_info_submitted: "shopify_checkout_shipping",
};

const TRACKED_QUERY_PARAMS = [
  "utm_id",
  "utm_source",
  "utm_medium",
  "utm_campaign",
  "utm_term",
  "utm_content",
  "fbclid",
  "gclid",
  "ttclid",
  "li_fat_id",
  "msclkid",
  "twclid",
  "rdt_cid",
  "sccid",
  "wbraid",
  "gbraid",
  "ig_sid",
];

function compact(object) {
  return Object.fromEntries(
    Object.entries(object).filter(
      ([, value]) =>
        value !== null &&
        value !== undefined &&
        value !== "",
    ),
  );
}

async function readCookie(name) {
  try {
    return (await browser.cookie.get(name)) || null;
  } catch {
    return null;
  }
}

async function readCookies() {
  const [fbp, fbc, ga, ttp] = await Promise.all([
    readCookie("_fbp"),
    readCookie("_fbc"),
    readCookie("_ga"),
    readCookie("_ttp"),
  ]);

  return { fbp, fbc, ga, ttp };
}

// On the very first page view of a visit the theme snippet may still be
// loading, so give its _wuid cookie a moment to appear — otherwise that page
// view would be reported twice.
async function readWuid(eventName) {
  const wuid = await readCookie("_wuid");
  if (wuid || eventName !== "page_viewed") return wuid;

  await new Promise((resolve) => setTimeout(resolve, 2000));
  return readCookie("_wuid");
}

function readQueryParameters(href) {
  if (!href) return {};

  try {
    const url = new URL(href);

    return compact(
      Object.fromEntries(
        TRACKED_QUERY_PARAMS.map((name) => [
          name,
          url.searchParams.get(name),
        ]),
      ),
    );
  } catch {
    return {};
  }
}

function readTimezone() {
  try {
    return Intl.DateTimeFormat()
      .resolvedOptions()
      .timeZone;
  } catch {
    return null;
  }
}

function buildContext(event, cookies) {
  const documentContext = event.context?.document;
  const navigatorContext = event.context?.navigator;
  const screen = event.context?.window?.screen;
  const href = documentContext?.location?.href;

  return compact({
    user_agent: navigatorContext?.userAgent,
    language: navigatorContext?.language,
    timezone: readTimezone(),
    screen_resolution: screen ? `${screen.width}x${screen.height}` : null,
    fbp: cookies.fbp,
    fbc: cookies.fbc,
    ga: cookies.ga,
    ttp: cookies.ttp,
    ...readQueryParameters(href),
  });
}

// Prefer the visitor ID the theme snippet stores in the _wuid cookie, so a
// checkout is tied to the storefront visit that led to it. The shopify_
// fallback covers pages where that cookie isn't readable.
function getAnonymousId(clientId, wuid) {
  if (wuid) return wuid;

  if (!clientId) return null;

  const anonymousId = `shopify_${clientId}`;

  if (anonymousId.length > 64) {
    console.error("Shopify client ID is too long");
    return null;
  }

  return anonymousId;
}

function getWhopEventName(shopifyEventName) {
  const name =
    EVENT_NAME_OVERRIDES[shopifyEventName] ||
    `shopify_${shopifyEventName}`;

  if (
    !WHOP_STANDARD_EVENTS.has(name) &&
    name.length > MAX_EVENT_NAME_LENGTH
  ) {
    console.error(
      "Whop event name too long, ad networks will drop it",
      name,
      name.length,
    );
  }

  return name;
}

function getEventId(event, checkout) {
  if (event.name === "checkout_completed") {
    const orderOrCheckoutId =
      checkout?.order?.id ||
      checkout?.token ||
      event.id;

    return `shopify:purchase:${orderOrCheckoutId}`;
  }

  return `shopify:${event.name}:${event.id}`;
}

function buildUser(event, checkout, wuid) {
  const anonymousId = getAnonymousId(event.clientId, wuid);

  if (!anonymousId) return null;

  const address =
    checkout?.shippingAddress ||
    checkout?.billingAddress ||
    {};

  const firstName = address.firstName || null;
  const lastName = address.lastName || null;

  return compact({
    anonymous_id: anonymousId,
    external_id:
      checkout?.order?.customer?.id || null,
    email: checkout?.email || null,
    phone:
      checkout?.phone ||
      address.phone ||
      null,
    first_name: firstName,
    last_name: lastName,
    name:
      [firstName, lastName]
        .filter(Boolean)
        .join(" ") || null,
    city: address.city || null,
    state:
      address.provinceCode ||
      address.province ||
      null,
    postal_code: address.zip || null,
    country:
      address.countryCode ||
      address.country ||
      null,
  });
}

function isCheckoutSurface(href) {
  if (!href) return false;

  try {
    const path = new URL(href).pathname;
    return path.includes("/checkouts") || path.includes("/orders/");
  } catch {
    return false;
  }
}

async function sendWhopEvent(payload) {
  try {
    const response = await fetch(WHOP_ENDPOINT, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(payload),
      keepalive: true,
      credentials: "omit",
    });

    const responseBody = await response.text();

    if (!response.ok) {
      console.error("Whop event failed", {
        status: response.status,
        response: responseBody,
        payload,
      });

      return;
    }

    console.log(
      "Whop event sent",
      payload.event_name,
      responseBody,
    );
  } catch (error) {
    console.error(
      "Whop request failed",
      payload.event_name,
      error,
    );
  }
}

async function handleShopifyEvent(event) {
  const href = event.context?.document?.location?.href || null;
  const wuid = await readWuid(event.name);

  // The theme snippet already reports storefront page views. Only checkout
  // and the order status page, where theme scripts can't run, need their
  // page views sent from here.
  if (
    event.name === "page_viewed" &&
    wuid &&
    !isCheckoutSurface(href)
  ) {
    return;
  }

  const checkout = event.data?.checkout;
  const user = buildUser(event, checkout, wuid);

  if (!user) {
    console.warn(
      "Shopify event missing a visitor ID",
      event.name,
    );
    return;
  }

  const cookies = await readCookies();
  const isPurchase =
    event.name === "checkout_completed";

  const payload = compact({
    account_id: WHOP_ACCOUNT_ID,
    event_name: getWhopEventName(event.name),
    event_id: getEventId(event, checkout),
    event_time: event.timestamp,
    action_source:
      event.name === "page_viewed" ? null : "website",
    url: href,
    referrer_url:
      event.context?.document?.referrer ||
      null,
    title:
      event.context?.document?.title ||
      null,
    user,
    context: buildContext(event, cookies),
  });

  if (
    isPurchase &&
    checkout?.totalPrice?.amount != null
  ) {
    payload.value = Number(
      checkout.totalPrice.amount,
    );

    const currency =
      checkout.totalPrice.currencyCode ||
      checkout.currencyCode;

    if (currency) {
      payload.currency = currency.toLowerCase();
    }
  }

  await sendWhopEvent(payload);
}

analytics.subscribe("page_viewed", handleShopifyEvent);

analytics.subscribe(
  "all_standard_events",
  async (event) => {
    if (
      event.name === "page_viewed" ||
      !TRACKED_EVENTS.has(event.name)
    ) {
      return;
    }

    await handleShopifyEvent(event);
  },
);
```

## 5. Sla de pixel op en verbind hem

Selecteer **Save** en daarna **Connect**. Shopify stuurt geen events naar een pixel die niet is verbonden.

## 6. Controleer of het tracken werkt

Bezoek een live storefrontpagina en controleer daarna de [Websites-pagina](https://whop.com/dashboard/websites) in je Whop-dashboard. Je domein verschijnt daar zodra er een paginaweergave binnenkomt. Plaats daarna een testbestelling en controleer of er ook een aankoop verschijnt.

Wanneer je de installatie live vanuit het dashboard verifieert, volgt de overlay je over de storefrontpagina's, maar verdwijnt hij zodra je de checkout opent. Shopify voert daar geen themascripts uit. Dat is normaal: de aangepaste pixel blijft checkout-events rapporteren en de testaankoop verschijnt nog steeds in je dashboard.

> [!NOTE]
>
> De automatische server-side tracking van aankopen door Whop geldt alleen voor checkouts die op Whop zelf plaatsvinden. Een Shopify-bestelling wordt volledig binnen Shopify verwerkt, dus Whop ziet die nooit, tenzij iets hem rapporteert. Daarvoor dient `checkout_completed` in dit script (verzonden als `purchase`). Verwijder het niet in de veronderstelling dat het een duplicaat is van de eigen tracking van Whop.


## Related topics

- [De Whop Pixel installeren](https://docs.whop.com/nl/developer/ads/pixel.md)
- [De Whop Pixel installeren op Kajabi](https://docs.whop.com/nl/developer/ads/platforms/kajabi.md)
- [De Whop Pixel installeren op WordPress](https://docs.whop.com/nl/developer/ads/platforms/wordpress.md)
