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

# Instala el píxel de Whop en Shopify

> Añade el píxel de Whop a una tienda de Shopify con un fragmento en el tema, además de un píxel personalizado que cubre el checkout.

Una instalación en Shopify tiene dos partes, y necesitas ambas:

1. **El fragmento del píxel en tu tema.** Se ejecuta en cada página de la tienda (inicio, productos, colecciones, carrito), donde registra a los visitantes y hace funcionar la superposición de instalación que ves al verificar tu píxel desde el panel de Whop.
2. **Un píxel personalizado.** El checkout de Shopify se ejecuta en un entorno aislado que ignora los scripts del tema, por lo que el fragmento deja de funcionar allí. La función **Custom Pixel** propia de Shopify es la forma de evitarlo: se ejecuta en todas las partes de tu tienda, incluido el checkout, e informa eventos estándar como `checkout_completed` y `payment_info_submitted`. El script del paso 4 reenvía cada uno a Whop, vinculado al mismo visitante que registra el fragmento del tema.

## 1. Obtén el ID de tu cuenta de Whop

Encuéntralo en tu [panel de Whop](https://whop.com/dashboard/): es la parte de la URL después de `dashboard/`, que empieza por `biz_`. Tiene este aspecto: `biz_xxxxxxxxxxx`.

![URL del panel de Whop en la barra de direcciones del navegador, con el ID de cuenta después de dashboard subrayado](https://mintcdn.com/whop/i81Det37UaKELkrh/images/dashboard-url.png?fit=max\&auto=format\&n=i81Det37UaKELkrh\&q=85\&s=f8dce6ea378318d4c89f7bce9239605d)

## 2. Añade el fragmento del píxel a tu tema

En Shopify, ve a **Online Store > Themes**. En tu tema actual, selecciona **⋯ > Edit code**. En **Layout**, abre `theme.liquid` y pega este fragmento justo antes de la etiqueta de cierre `</head>`. Reemplaza `biz_xxxxxxxxxxxxx` por el ID de tu propia cuenta y luego selecciona **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>
```

Como `theme.liquid` envuelve cada página de la tienda, esta única edición cubre toda tu tienda. No pegues el fragmento en una sola plantilla de página o sección. Un visitante que llegue a cualquier otro lugar no quedaría registrado, y la superposición de instalación desaparecería en cuanto salieras de esa página.

## 3. Añade un píxel personalizado

En Shopify, ve a **Settings > Customer events** y selecciona **Add custom pixel**. Llámalo `Whop`.

## 4. Pega el script

Pega esto en el editor de código del píxel. Reemplaza `biz_xxxxxxxxxxxxx` por el ID de tu propia cuenta.

El script lee la cookie `_wuid` que establece el fragmento del tema, de modo que los eventos del checkout se asocian al mismo visitante que el fragmento del tema ha estado registrando. También omite las visitas a páginas de la tienda (el fragmento del tema ya las informa) y solo envía las visitas a páginas del checkout, donde los scripts del tema no pueden ejecutarse.

```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. Guarda y conecta el píxel

Selecciona **Save** y luego **Connect**. Shopify no envía ningún evento a un píxel sin conectar.

## 6. Confirma que está registrando

Visita una página publicada de la tienda y luego revisa la [página Websites](https://whop.com/dashboard/websites) en tu panel de Whop. Tu dominio aparecerá allí en cuanto llegue una visita a la página. Después, realiza un pedido de prueba y confirma que también aparece una compra.

Cuando verificas la instalación en vivo desde el panel, la superposición te sigue por las páginas de la tienda, pero desaparece al entrar en el checkout, porque Shopify no ejecuta allí los scripts del tema. Es lo esperado: el píxel personalizado sigue informando los eventos del checkout, y la compra de prueba aparece igualmente en tu panel.

> [!NOTE]
>
> El registro automático de compras en el servidor de Whop solo cubre los checkouts que ocurren en el propio Whop. Un pedido de Shopify se procesa íntegramente dentro de Shopify, por lo que Whop nunca lo ve a menos que algo lo informe: para eso sirve el `checkout_completed` de este script (enviado como `purchase`). No lo elimines pensando que es un duplicado del registro propio de Whop.


## Related topics

- [Instala el píxel de Whop](https://docs.whop.com/es/developer/ads/pixel.md)
- [Instala el píxel de Whop en Kajabi](https://docs.whop.com/es/developer/ads/platforms/kajabi.md)
- [Instala el píxel de Whop en WordPress](https://docs.whop.com/es/developer/ads/platforms/wordpress.md)
