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

# Autenticar usuarios en las apps de Whop

> Verifica el usuario actual y comprueba su nivel de acceso dentro de tu app de Whop.

Las apps de Whop se muestran dentro de un iframe en `whop.com`. Para saber *quién* hace una solicitud a tu app, Whop pasa un JSON Web Token (JWT) de corta duración en la cabecera `x-whop-user-token` en cada solicitud del mismo origen. Verificas este token con el SDK para obtener un ID de usuario y luego compruebas qué puede ver ese usuario.

## Verificar el token de usuario del iframe

> [!WARNING]
>
> `verifyUserToken` no está disponible en el `@whop/sdk` actual, así que los fragmentos de TypeScript de esta página se mantienen como referencia y no funcionarán tal como están escritos. Python es distinto: `whop-sdk` incluye la función auxiliar como `whop_sdk.lib.verify_user_token`, que necesita PyJWT instalado junto a ella (`pip install "pyjwt[crypto]"`). La gema `whop_sdk` también la incluye, pero como función de módulo en un espacio de nombres raíz distinto al del cliente: `WhopSDK::Helpers::VerifyUserToken.verify_user_token!`, mientras que el cliente es `Whop_sdk::Client`. No es un método del cliente, y la gema ya depende de `jwt`.

Llama a `verifyUserToken` en cada solicitud. Lee la cabecera `x-whop-user-token`, valida la firma y la caducidad del JWT y devuelve el ID de usuario. Los tokens no válidos lanzan una excepción de forma predeterminada. TypeScript y Python también ofrecen una variante que no lanza excepciones:

| Lenguaje | Variante que no lanza excepciones |
| - | - |
| TypeScript | Pasa `{ dontThrow: true }` como segundo argumento |
| Python | Llama a `try_verify_user_token`, que devuelve `None` en lugar de lanzar una excepción |
| Ruby | Ninguna. `verify_user_token!` es el único punto de entrada, así que captura `StandardError`. |

```typescript JS/TS + NextJS theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function MyServerRenderedPage() {
	const { userId } = await whopsdk.verifyUserToken(await headers());

    // ... the rest of your component / api route etc...
}
```

```javascript JS/TS + ExpressJS theme={null}
import express from "express";
import { whopsdk } from "./lib/whop-sdk";

const app = express();

app.get("/my-route", async (req, res) => {
    const { userId } = await whopsdk.verifyUserToken(req.headers);

    // ... the rest of your route handler
});
```

```python Python + FastAPI theme={null}
from fastapi import FastAPI, Request
from whop_sdk.lib.verify_user_token import verify_user_token

app = FastAPI()

@app.get("/my-route")
async def my_route(request: Request):
    # Synchronous, and app_id is required: it is checked against the token's audience.
    result = verify_user_token(request.headers, app_id="app_xxxxxxxxxxxxx")
    user_id = result.user_id

    # ... the rest of your route handler
```

```ruby Ruby on Rails theme={null}
class MyController < ApplicationController
  def my_action
    # Give the helper a token string or a plain Hash, not an ActionDispatch headers object.
    # app_id is optional in Ruby. Pass it to check the token's audience.
    auth_result = WhopSDK::Helpers::VerifyUserToken.verify_user_token!(
      request.headers["x-whop-user-token"],
      app_id: "app_xxxxxxxxxxxxx",
    )
    user_id = auth_result.user_id

    # ... the rest of your controller action
  end
end
```

El token solo se adjunta a las solicitudes dirigidas al `window.location.origin` de tu iframe. Ejemplos:

* Navegación relativa entre páginas: `<a href="/sub_page">...</a>`
* Fetch sin dominio: `await fetch("/api/quizzes")`

Estas se resuelven a tu dominio `App.base_url`.

> [accordion] La API está en otro dominio
>
> Si tu frontend se ejecuta en `example.com` pero tu API se ejecuta en `api.example.com`, redirige las solicitudes a la API mediante un proxy inverso a través de `example.com/api` para que lleven la cabecera `x-whop-user-token`.
>
> * **Cloudflare**: crea una ["origin rule"](https://developers.cloudflare.com/rules/origin-rules/features/#dns-record) desde `/api` en `example.com` que reescriba a `api.example.com/api`.
>
> * **Next.js**: añade un [rewrite](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites) en `next.config.mjs`.
>
> * **nginx / Caddy**: usa la primitiva de reescritura en la configuración de tu servidor.
>
> > [!NOTE]
> >
> > Esta configuración es necesaria por las estrictas políticas de cookies entre orígenes de los navegadores.

## Configuración local

Whop ofrece un proxy inverso local que reproduce el comportamiento del iframe y de las cookies de producción, para que el código que escribas funcione igual en `localhost` y en producción. Consulta la [guía del proxy de desarrollo](https://docs.whop.com/es/developer/guides/dev-proxy.md) para configurarlo.

## Comprobar el acceso

Ahora que sabes quién hace la solicitud, comprueba qué puede ver. Usa el método [`checkAccess`](https://docs.whop.com/es/api-reference/users/check-user-access) para verificar el acceso a una experiencia, una cuenta o un producto.

```typescript JS/TS theme={null}
import { whopsdk } from "@/lib/whop-sdk";

const response = await whopsdk.users.checkAccess({
    id: "user_xxxxxxxxxxxxx",
    resource_id: "resource_id",
});

// Response:
// {
//   "has_access": true,
//   "access_level": "customer"
// }
```

```python Python theme={null}
response = whopsdk.users.check_access(
    resource_id="resource_id",
    id="user_xxxxxxxxxxxxx",
)

# Response:
# {
#   "has_access": True,
#   "access_level": "customer"
# }
```

```ruby Ruby theme={null}
response = whopsdk.users.check_access(
  resource_id: "resource_id",
  id: "user_xxxxxxxxxxxxx",
)

# Response:
# {
#   "has_access": true,
#   "access_level": "customer"
# }
```

```rust Rust theme={null}
let response = client
    .users
    .check_access(&"user_xxxxxxxxxxxxx".to_string(), &"resource_id".to_string(), None)
    .await?;

println!("{} {}", response.has_access, response.access_level);
// has_access => true, access_level => "customer"
```

```go Go theme={null}
response, err := client.Users.CheckAccess(context.TODO(), &whopsdk.CheckAccessUsersRequest{
    ID:         "user_xxxxxxxxxxxxx",
    ResourceID: "resource_id",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(response.HasAccess, response.AccessLevel)
// has_access => true, access_level => "customer"
```

```bash cURL theme={null}
curl --request GET \
  --url https://api.whop.com/api/v1/users/{id}/access/{resource_id} \
  --header 'Authorization: Bearer <token>'
```

### IDs de recurso y niveles de acceso

| Prefijo de `resource_id` | Comprueba el acceso a |
| - | - |
| `biz_xxxx` | Cuenta |
| `prod_xxxx` | Producto |
| `exp_xxxx` | Experiencia |

El `access_level` de la respuesta es uno de los siguientes:

| Nivel | Significado |
| - | - |
| `customer` | El usuario tiene una membresía válida. Para una experiencia, tiene una membresía de cualquier producto conectado a ella. Para un producto, de ese producto concreto. Para una cuenta, de cualquier producto de la cuenta. |
| `admin` | El usuario es miembro del equipo de la cuenta (cualquier rol, incluido moderador). |
| `no_access` | El usuario no tiene acceso (`has_access` es `false`). |

### App para clientes (vista de experiencia)

Las apps para clientes deben restringir el acceso según el `experienceId` que se pasa en los parámetros de ruta. Devuelve `no_access` o redirige si el usuario no tiene una membresía válida.

```typescript theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function ExperiencePage({
    params,
}: {
    params: Promise<{ experienceId: string }>;
}) {
    const { experienceId } = await params;
    const { userId } = await whopsdk.verifyUserToken(await headers());

    const access = await whopsdk.users.checkAccess({
        id: userId,
        resource_id: experienceId,
    });

    if (!access.has_access) {
        return <div>Access denied</div>;
    }

    return <div>Welcome to the experience!</div>;
}
```

El mismo patrón funciona en una ruta de API. Cambia `headers()` por `request.headers` y devuelve una `403 Response` en lugar de JSX.

### App de panel (vista de panel)

Las apps de panel deben restringir el acceso con `access_level === "admin"` para que solo los miembros del equipo de la cuenta puedan cargar la vista.

```typescript theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function DashboardPage({
    params,
}: {
    params: Promise<{ companyId: string }>;
}) {
    const { companyId } = await params;
    const { userId } = await whopsdk.verifyUserToken(await headers());

    const access = await whopsdk.users.checkAccess({
        id: userId,
        resource_id: companyId,
    });

    if (access.access_level !== "admin") {
        return <div>Admin access required</div>;
    }

    return <div>Welcome to the dashboard!</div>;
}
```

El mismo patrón en una ruta de API. Cambia `headers()` por `request.headers` y devuelve una `403 Response` en lugar de JSX.

## Próximos pasos

> [card] [Ejecutar un proxy de desarrollo local](https://docs.whop.com/es/developer/guides/dev-proxy.md)
>
> Reproduce en localhost la configuración del iframe y las cookies de producción.

> [card] [Solicitar permisos](https://docs.whop.com/es/developer/guides/permissions.md)
>
> Añade los alcances que necesita tu app antes de publicarla.

> [card] [Escuchar webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Recibe eventos de pagos, membresías y entradas en tu servidor.

> [card] [Crear una vista de app](https://docs.whop.com/es/developer/guides/app-views.md)
>
> Configura vistas de panel, experiencias y fichas de Discover.


## Related topics

- [Crea apps de Whop con React Native](https://docs.whop.com/es/developer/guides/react-native.md)
- [Conceptos principales de la API de Whop](https://docs.whop.com/es/developer/concepts.md)
- [Proxy de desarrollo](https://docs.whop.com/es/developer/guides/dev-proxy.md)
