> ## 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.

# Installér Whop Pixel på Shopify

> Tilføj Whop Pixel til en Shopify-butiksfront med et tema-snippet plus en brugerdefineret pixel, der dækker checkout.

En Shopify-installation består af to dele, og du skal bruge begge:

1. **Pixel-snippet'et i dit tema.** Det kører på hver side i butiksfronten – forside, produkter, kollektioner, kurv – hvor det sporer besøgende og driver det installations-overlay, du ser, når du verificerer din pixel fra Whop-dashboardet.
2. **En brugerdefineret pixel.** Shopifys checkout kører i en sandbox, der ignorerer tema-scripts, så snippet'et går i sort der. Shopifys egen **Custom Pixel**-funktion er vejen udenom – den kører i alle dele af din butik, checkout inklusive, og rapporterer standardhændelser som `checkout_completed` og `payment_info_submitted`. Scriptet i trin 4 videresender hver af dem til Whop, knyttet til den samme besøgende, som tema-snippet'et sporer.

## 1. Find dit Whop-konto-ID

Find det i dit [Whop Dashboard](https://whop.com/dashboard/) – den del af URL'en, der kommer efter `dashboard/`, og som starter med `biz_`. Det ser sådan ud: `biz_xxxxxxxxxxx`.

![Whop-dashboardets URL i browserens adresselinje, med konto-ID'et efter dashboard understreget](https://mintcdn.com/whop/i81Det37UaKELkrh/images/dashboard-url.png?fit=max\&auto=format\&n=i81Det37UaKELkrh\&q=85\&s=f8dce6ea378318d4c89f7bce9239605d)

## 2. Tilføj pixel-snippet'et til dit tema

I Shopify skal du gå til **Online Store > Themes**. På dit nuværende tema skal du vælge **⋯ > Edit code**. Under **Layout** skal du åbne `theme.liquid` og indsætte dette snippet umiddelbart før det afsluttende `</head>`-tag. Erstat `biz_xxxxxxxxxxxxx` med dit eget konto-ID, og vælg derefter **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>
```

Fordi `theme.liquid` omkranser hver side i butiksfronten, dækker denne ene redigering hele din butik. Indsæt ikke i stedet snippet'et i en enkelt side- eller sektionsskabelon. En besøgende, der lander et andet sted, ville ikke blive sporet, og installations-overlayet ville forsvinde, så snart du navigerer væk fra den side.

## 3. Tilføj en brugerdefineret pixel

I Shopify skal du gå til **Settings > Customer events** og derefter vælge **Add custom pixel**. Giv den navnet `Whop`.

## 4. Indsæt scriptet

Indsæt dette i pixlens kodeeditor. Erstat `biz_xxxxxxxxxxxxx` med dit eget konto-ID.

Scriptet læser den `_wuid`-cookie, som tema-snippet'et sætter, så checkout-hændelser lander på den samme besøgende, som tema-snippet'et har sporet. Det springer også sidevisninger i butiksfronten over – tema-snippet'et rapporterer allerede dem – og sender kun sidevisninger fra checkout, hvor tema-scripts ikke kan køre.

```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. Gem og forbind pixlen

Vælg **Save** og derefter **Connect**. Shopify sender ingen hændelser til en pixel, der ikke er forbundet.

## 6. Bekræft, at sporingen virker

Besøg en live side i butiksfronten, og tjek derefter [siden Websites](https://whop.com/dashboard/websites) i dit Whop-dashboard. Dit domæne vises der, så snart en sidevisning kommer igennem. Afgiv derefter en testordre, og bekræft, at et køb også dukker op.

Når du verificerer installationen live fra dashboardet, følger overlayet dig på tværs af siderne i butiksfronten, men forsvinder, når du går ind i checkout – Shopify kører ikke tema-scripts der. Det er forventet: den brugerdefinerede pixel fortsætter med at rapportere checkout-hændelser, og testkøbet dukker stadig op i dit dashboard.

> [!NOTE]
>
> Whops automatiske server-side sporing af køb dækker kun checkouts, der sker på selve Whop. En Shopify-ordre behandles udelukkende inde i Shopify, så Whop ser den aldrig, medmindre noget rapporterer den – det er det, dette scripts `checkout_completed` (sendt som `purchase`) er til. Fjern det ikke i den tro, at det er en dublet af Whops egen sporing.


## Related topics

- [Installér Whop Pixel](https://docs.whop.com/da/developer/ads/pixel.md)
- [Installér Whop Pixel på Kajabi](https://docs.whop.com/da/developer/ads/platforms/kajabi.md)
- [Installér Whop Pixel på WordPress](https://docs.whop.com/da/developer/ads/platforms/wordpress.md)
