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

# Whop Pixel'i Shopify'a kurun

> Whop Pixel'i bir tema kod parçacığıyla ve ödeme sayfasını kapsayan özel bir pikselle Shopify mağazanıza ekleyin.

Shopify kurulumu iki bölümden oluşur ve ikisine de ihtiyacınız vardır:

1. **Temanızdaki piksel kod parçacığı.** Her mağaza sayfasında (ana sayfa, ürünler, koleksiyonlar, sepet) çalışır; burada ziyaretçileri izler ve pikselinizi Whop kontrol panelinden doğrularken gördüğünüz kurulum katmanını çalıştırır.
2. **Özel bir piksel.** Shopify'ın ödeme sayfası tema betiklerini yok sayan bir korumalı alanda (sandbox) çalışır, bu nedenle kod parçacığı orada devre dışı kalır. Bunu aşmanın yolu Shopify'ın kendi **Custom Pixel** özelliğidir: ödeme sayfası dahil mağazanızın her bölümünde çalışır ve `checkout_completed` ve `payment_info_submitted` gibi standart olayları bildirir. 4. adımdaki betik, bunların her birini tema kod parçacığının izlediği aynı ziyaretçiye bağlı olarak Whop'a iletir.

## 1. Whop Hesap Kimliğinizi alın

Bunu [Whop Kontrol Panelinizden](https://whop.com/dashboard/) bulabilirsiniz: URL'nin `dashboard/` sonrasındaki, `biz_` ile başlayan kısmı. `biz_xxxxxxxxxxx` gibi görünür.

![Tarayıcı adres çubuğunda Whop kontrol paneli URL'si; dashboard sonrasındaki hesap kimliğinin altı çizili](https://mintcdn.com/whop/i81Det37UaKELkrh/images/dashboard-url.png?fit=max\&auto=format\&n=i81Det37UaKELkrh\&q=85\&s=f8dce6ea378318d4c89f7bce9239605d)

## 2. Piksel kod parçacığını temanıza ekleyin

Shopify'da **Online Store > Themes** bölümüne gidin. Mevcut temanızda **⋯ > Edit code** seçeneğini seçin. **Layout** altında `theme.liquid` dosyasını açın ve bu kod parçacığını kapanış `</head>` etiketinin hemen önüne yapıştırın. `biz_xxxxxxxxxxxxx` değerini kendi hesap kimliğinizle değiştirin, ardından **Save** seçeneğini seçin.

```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>
```

`theme.liquid` her mağaza sayfasını sardığı için bu tek düzenleme tüm mağazanızı kapsar. Kod parçacığını bunun yerine tek bir sayfa veya bölüm şablonuna yapıştırmayın. Başka bir yere ulaşan bir ziyaretçi izlenmez ve kurulum katmanı o sayfadan ayrıldığınız anda kaybolur.

## 3. Özel bir piksel ekleyin

Shopify'da **Settings > Customer events** bölümüne gidin, ardından **Add custom pixel** seçeneğini seçin. Adını `Whop` olarak belirleyin.

## 4. Betiği yapıştırın

Bunu pikselin kod düzenleyicisine yapıştırın. `biz_xxxxxxxxxxxxx` değerini kendi hesap kimliğinizle değiştirin.

Betik, tema kod parçacığının ayarladığı `_wuid` çerezini okur; böylece ödeme olayları, tema kod parçacığının izlediği aynı ziyaretçiye kaydedilir. Ayrıca mağaza sayfası görüntülemelerini atlar (tema kod parçacığı bunları zaten bildirir) ve yalnızca tema betiklerinin çalışamadığı ödeme sayfasından gelen sayfa görüntülemelerini gönderir.

```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. Pikseli kaydedin ve bağlayın

**Save** seçeneğini, ardından **Connect** seçeneğini seçin. Shopify, bağlı olmayan bir piksele hiçbir olay göndermez.

## 6. İzlendiğini doğrulayın

Yayındaki bir mağaza sayfasını ziyaret edin, ardından Whop kontrol panelinizdeki [Websites sayfasını](https://whop.com/dashboard/websites) kontrol edin. Bir sayfa görüntülemesi geldiğinde alan adınız orada görünür. Ardından bir test siparişi verin ve bir satın almanın da göründüğünü doğrulayın.

Kurulumu kontrol panelinden canlı olarak doğruladığınızda, katman mağaza sayfaları boyunca sizi takip eder ancak ödeme sayfasına girdiğinizde kaybolur; Shopify orada tema betiklerini çalıştırmaz. Bu beklenen bir durumdur: özel piksel ödeme olaylarını bildirmeye devam eder ve test satın alması kontrol panelinizde yine görünür.

> [!NOTE]
>
> Whop'un otomatik sunucu tarafı satın alma izlemesi yalnızca Whop'un kendisinde gerçekleşen ödemeleri kapsar. Bir Shopify siparişi tamamen Shopify içinde işlenir, bu nedenle bir şey onu bildirmedikçe Whop onu asla görmez; bu betikteki `checkout_completed` (`purchase` olarak gönderilir) bunun içindir. Whop'un kendi izlemesinin bir kopyası olduğunu düşünerek onu kaldırmayın.


## Related topics

- [Whop Pixel'i kurun](https://docs.whop.com/tr/developer/ads/pixel.md)
- [Whop Pixel'i Kajabi'ye kurun](https://docs.whop.com/tr/developer/ads/platforms/kajabi.md)
- [Whop Pixel'i Calendly ile kurun](https://docs.whop.com/tr/developer/ads/platforms/calendly.md)
