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

# SaaS

> Vende tu software en Whop. Restringe una app web comprobando el acceso de cada usuario, o restringe el software descargable con claves de licencia.

Whop gestiona el checkout, la facturación y la administración de suscripciones de tu software. Antes de que tu app deje entrar a alguien, comprueba con Whop que el cliente tiene acceso en ese momento. Esta página muestra las dos formas de hacer esa comprobación.

## Elige tu integración

| | Comprobación de acceso | Claves de licencia |
| - | - | - |
| **Ideal para** | Una app web en la que los usuarios inician sesión en tu sitio | Apps de escritorio, scripts y herramientas que descargan los usuarios |
| **Qué identifica al cliente** | Su ID de usuario de Whop, guardado en tu registro de usuario | Una clave de licencia que Whop emite con cada compra |
| **A qué llama tu servidor** | `users.checkAccess` | `memberships.retrieve` and `memberships.update` |
| **Limitar a una máquina** | No | Sí, con un ID de hardware en los metadatos de la membresía |

Ambas opciones comparten la misma configuración.

## Configuración

### 1. Crea tu whop y un producto

Empieza en [whop.com/sell](https://whop.com/dashboard/start/) para ponerle nombre a tu whop y elegir su URL. Después, ve a **Products** en tu panel y añade un producto con el precio que pagan tus clientes. Copia el ID del producto (`prod_`) y el ID de su plan (`plan_`). Necesitarás ambos más adelante.

### 2. Crea una clave de API

En tu panel, ve a **Developer → API keys** y crea una clave de API de cuenta. Actúa en nombre de tu negocio, así que mantenla en tu servidor y nunca la incluyas en código de cliente ni en una app descargable. Guárdala como `WHOP_API_KEY`.

### 3. Instala el SDK

```bash npm theme={null}
npm install @whop/sdk
```

```bash pip theme={null}
pip install whop-sdk
```

Crea un único cliente y reutilízalo. Los ejemplos de esta página lo llaman `client`.

```typescript TypeScript theme={null}
import { WhopClient } from "@whop/sdk";

export const client = new WhopClient({ token: process.env.WHOP_API_KEY });
```

```python Python theme={null}
import os

from whop_sdk import Whop

client = Whop(token=os.environ["WHOP_API_KEY"])
```

## Integración con inicio de sesión por correo electrónico

Usa esta opción cuando los clientes inicien sesión en tu propia app web. Guarda el ID de usuario de Whop de cada cliente en tu registro de usuario y, después, úsalo para comprobar el acceso antes de ofrecer funciones de pago.

### 1. Añade columnas de Whop a tu tabla de usuarios

| Columna | Tipo | Descripción |
| - | - | - |
| `whop_user_id` | string | El ID de usuario de Whop del cliente, con el prefijo `user_`. |
| `whop_username` | string | Opcional. El nombre de usuario de Whop del cliente. Muéstralo en tu interfaz y en tus registros. |

### 2. Envía al checkout a los usuarios que han iniciado sesión

Crea una configuración de checkout desde tu servidor y pon tu propio ID de usuario en `metadata`. Whop copia esos metadatos en la membresía, que es como el siguiente paso vincula la compra con tu usuario. Después, redirige al usuario a `purchase_url`.

```typescript TypeScript theme={null}
export async function startCheckout(userId: string) {
  const checkout = await client.checkoutConfigurations.create({
    variant_id: process.env.WHOP_VARIANT_ID!,
    metadata: { customer_id: userId },
    redirect_url: "https://yourapp.com/billing/return",
  });

  return checkout.purchase_url;
}
```

```python Python theme={null}
def start_checkout(user_id: str) -> str:
    checkout = client.checkout_configurations.create(
        variant_id=os.environ["WHOP_VARIANT_ID"],
        metadata={"customer_id": user_id},
        redirect_url="https://yourapp.com/billing/return",
    )

    return checkout.purchase_url
```

Para mantener a los compradores en tu propia página, [integra el elemento Checkout](https://docs.whop.com/es/developer/guides/embed-checkout.md) y pasa los mismos `metadata` en su handle. [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md) compara todas las opciones de checkout.

### 3. Guarda el ID de usuario de Whop desde el webhook

Abre la [pestaña Developer de tu panel](https://whop.com/dashboard/developer), selecciona **Create webhook**, suscríbete a `membership.activated` y guarda el secreto de firma como `WHOP_WEBHOOK_SECRET`. El `data` del evento es la membresía, con el `user_id` del comprador y los `metadata` que estableciste en el checkout.

```typescript TypeScript theme={null}
// app/api/webhooks/whop/route.ts
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
  // Verify the raw body. Parsing it first changes the bytes and the signature check fails.
  const event = unwrapWebhook(await request.text(), {
    headers: Object.fromEntries(request.headers),
    key: process.env.WHOP_WEBHOOK_SECRET!,
  });

  if (event.type === "membership.activated") {
    const customerId = event.data.metadata?.customer_id;
    if (customerId && event.data.user_id) {
      await db.users.update(customerId, { whop_user_id: event.data.user_id });
    }
  }

  return new Response("OK", { status: 200 });
}
```

```python Python theme={null}
import os

from fastapi import FastAPI, Request, Response
from whop_sdk.lib.verify_webhook import unwrap

app = FastAPI()


@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request):
    # Verify the raw body. Parsing it first changes the bytes and the signature check fails.
    event = unwrap(await request.body(), dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "membership.activated":
        membership = event["data"]
        customer_id = (membership.get("metadata") or {}).get("customer_id")
        if customer_id and membership.get("user_id"):
            db.users.update(customer_id, whop_user_id=membership["user_id"])

    return Response(status_code=200)
```

`membership.activated` también se activa en las renovaciones, así que asegúrate de que la escritura se pueda repetir sin problemas. [Webhooks](https://docs.whop.com/es/developer/guides/webhooks.md) explica los reintentos y las pruebas.

### 4. Comprueba el acceso antes de ofrecer funciones de pago

Pregunta a Whop si el usuario tiene acceso a tu producto. La respuesta tiene en cuenta las renovaciones, cancelaciones y reembolsos, así que no necesitas hacer el seguimiento del estado de facturación tú mismo.

```typescript TypeScript theme={null}
export async function hasAccess(whopUserId: string) {
  const access = await client.users.checkAccess({
    id: whopUserId,
    resource_id: process.env.WHOP_PRODUCT_ID!,
  });

  return access.has_access;
}
```

```python Python theme={null}
def has_access(whop_user_id: str) -> bool:
    access = client.users.check_access(
        resource_id=os.environ["WHOP_PRODUCT_ID"],
        id=whop_user_id,
    )

    return access.has_access
```

`access_level` en la misma respuesta es `customer`, `admin` o `no_access`.

### 5. Permite que los clientes gestionen su facturación

Enlaza a los clientes a sus [pedidos de Whop](https://whop.com/@me/settings/orders) para que actualicen su método de pago o cancelen. Inician sesión con el correo electrónico con el que compraron.

## Integración con claves de licencia

Usa esta opción para software que se ejecuta en la máquina del cliente. Cada compra incluye una clave de licencia única. Tu software pide la clave y tu servidor la comprueba con Whop.

### 1. Añade la app Software a tu producto

[Instala la app Software](https://whop.com/apps/app_jHH5YT7jHYQANi/install/) en tu whop, ábrela y añade el nombre de tu software y el enlace de descarga. Así, los compradores ven su clave de licencia y la descarga en sus pedidos. La API devuelve la `license_key` de una membresía solo cuando su producto incluye esta app.

### 2. Valida las claves desde tu servidor

Comprueba las claves desde tu propio servidor, nunca desde el software que distribuyes. Tu clave de API puede leer y modificar todas las membresías de tu negocio, así que nunca la incluyas en una app de escritorio o un script que descarguen los usuarios. Tu software envía la clave de licencia y un identificador de la máquina a tu servidor, y tu servidor la comprueba con Whop.

Para limitar cada clave a una sola máquina, guarda un ID de hardware en los metadatos de la membresía la primera vez que alguien use la clave y, después, compáralo en cada comprobación posterior:

* **La clave aún no está vinculada** (no hay `hwid` en sus metadatos): guarda el `hwid` de la máquina y concede el acceso.
* **El `hwid` guardado coincide:** concede el acceso.
* **El `hwid` guardado es distinto:** deniega el acceso. La clave está en uso en otra máquina hasta que el cliente la restablezca.

```typescript TypeScript theme={null}
// Add "past_due" if you let customers keep access while Whop retries a failed renewal.
const VALID_STATUSES = ["active", "trialing", "completed"];

export async function validateLicense(licenseKey: string, hwid: string) {
  // Retrieve accepts a license key in place of a membership ID. An unknown key throws a 404 error.
  const membership = await client.memberships.retrieve({ id: licenseKey });

  if (!VALID_STATUSES.includes(membership.status)) {
    return { valid: false, reason: "membership_inactive" };
  }

  const boundHwid = membership.metadata?.hwid;

  if (!boundHwid) {
    // Update merges these keys into the existing metadata.
    await client.memberships.update({ id: membership.id, metadata: { hwid } });
    return { valid: true };
  }

  if (boundHwid !== hwid) {
    return { valid: false, reason: "bound_to_another_machine" };
  }

  return { valid: true };
}
```

```python Python theme={null}
# Add "past_due" if you let customers keep access while Whop retries a failed renewal.
VALID_STATUSES = {"active", "trialing", "completed"}


def validate_license(license_key: str, hwid: str) -> dict:
    # Retrieve accepts a license key in place of a membership ID. An unknown key raises a 404 error.
    membership = client.memberships.retrieve(license_key)

    if membership.status not in VALID_STATUSES:
        return {"valid": False, "reason": "membership_inactive"}

    bound_hwid = (membership.metadata or {}).get("hwid")

    if not bound_hwid:
        # Update merges these keys into the existing metadata.
        client.memberships.update(membership.id, metadata={"hwid": hwid})
        return {"valid": True}

    if bound_hwid != hwid:
        return {"valid": False, "reason": "bound_to_another_machine"}

    return {"valid": True}
```

### 3. Restablece una clave de licencia

Los clientes pueden restablecer su clave desde sus pedidos. Para restablecerla desde tu servidor, [actualiza la membresía](https://docs.whop.com/es/api-reference/memberships/update-membership.md) con un objeto de metadatos vacío (`metadata: {}`). La siguiente comprobación desde cualquier máquina vuelve a vincular la clave.

## Diseña la página de tu tienda

La página de tu tienda es donde la gente conoce tu software antes de comprarlo. Selecciona el nombre de tu whop en la parte superior izquierda y, a continuación, selecciona **Design store page** para abrir el editor. Selecciona **Edit details** para personalizar:

* **Nombre y titular:** explica qué hace el software y a quién va dirigido.
* **Descripción:** céntrate en el problema que resuelve y en lo que obtienen los compradores, como actualizaciones, soporte o una comunidad.
* **Logotipo:** añade un logotipo limpio y sencillo.
* **Imágenes o vídeo de la galería:** muestra el software en uso. Un vídeo de demostración breve ayuda a los compradores a decidirse.
* **Categoría:** elige la categoría que ayude a la gente a encontrar tu software al explorar Whop.

## Próximos pasos

> [card] [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md)
>
> Compara los enlaces de checkout, el elemento Checkout y los payment elements.

> [card] [Webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Verifica firmas, gestiona reintentos y prueba eventos.

> [card] [Gestionar membresías](https://docs.whop.com/es/developer/guides/memberships.md)
>
> Cancela, pausa, amplía y actualiza membresías desde tu servidor.

> [card] [Iniciar sesión con Whop](https://docs.whop.com/es/developer/guides/oauth.md)
>
> Permite que los clientes inicien sesión con su cuenta de Whop en lugar de con una contraseña.


## Related topics

- [Empieza con Whop](https://docs.whop.com/es/get-started.md)
- [Qué son las apps de Whop](https://docs.whop.com/es/whop-apps/what-are-whop-apps.md)
