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

# Authentifier les utilisateurs dans les applications Whop

> Vérifiez l'utilisateur actuel et contrôlez son niveau d'accès dans votre application Whop.

Les applications Whop s'affichent dans une iframe sur `whop.com`. Pour savoir *qui* envoie une requête à votre application, Whop transmet un JSON Web Token (JWT) de courte durée dans l'en-tête `x-whop-user-token` de chaque requête de même origine. Vous vérifiez ce jeton avec le SDK pour obtenir un ID utilisateur, puis vous contrôlez ce que cet utilisateur peut voir.

## Vérifier le jeton utilisateur de l'iframe

> [!WARNING]
>
> `verifyUserToken` n'est pas disponible dans la version actuelle de `@whop/sdk` : les extraits TypeScript de cette page sont donc conservés à titre de référence et ne fonctionneront pas en l'état. Python est différent : `whop-sdk` fournit la fonction utilitaire sous le nom `whop_sdk.lib.verify_user_token`, qui nécessite l'installation de PyJWT à côté (`pip install "pyjwt[crypto]"`). La gem `whop_sdk` la fournit également, mais sous forme de fonction de module dans un espace de noms racine différent de celui du client : `WhopSDK::Helpers::VerifyUserToken.verify_user_token!`, alors que le client est `Whop_sdk::Client`. Ce n'est pas une méthode du client, et la gem dépend déjà de `jwt`.

Appelez `verifyUserToken` à chaque requête. Cette fonction lit l'en-tête `x-whop-user-token`, valide la signature et l'expiration du JWT, puis renvoie l'ID utilisateur. Par défaut, les jetons invalides lèvent une exception. TypeScript et Python proposent aussi une variante qui ne lève pas d'exception :

| Langage | Variante sans exception |
| - | - |
| TypeScript | Transmettez `{ dontThrow: true }` comme second argument |
| Python | Appelez `try_verify_user_token`, qui renvoie `None` au lieu de lever une exception |
| Ruby | Aucune. `verify_user_token!` est le seul point d'entrée : interceptez donc `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
```

Le jeton n'est joint qu'aux requêtes qui atteignent le `window.location.origin` de votre iframe. Exemples :

* Navigation relative entre pages : `<a href="/sub_page">...</a>`
* Requêtes fetch sans domaine : `await fetch("/api/quizzes")`

Elles sont résolues vers le domaine de votre `App.base_url`.

> [accordion] L'API se trouve sur un autre domaine
>
> Si votre frontend s'exécute sur `example.com` mais votre API sur `api.example.com`, faites passer les requêtes API par un reverse proxy via `example.com/api` afin qu'elles portent l'en-tête `x-whop-user-token`.
>
> * **Cloudflare** : créez une [« origin rule »](https://developers.cloudflare.com/rules/origin-rules/features/#dns-record) de `/api` sur `example.com` pour réécrire vers `api.example.com/api`.
>
> * **Next.js** : ajoutez un [rewrite](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites) dans `next.config.mjs`.
>
> * **nginx / Caddy** : utilisez la primitive de réécriture dans la configuration de votre serveur.
>
> > [!NOTE]
> >
> > Cette configuration est nécessaire en raison des politiques strictes des navigateurs en matière de cookies cross-origin.

## Configuration locale

Whop fournit un reverse proxy local qui reproduit le comportement de l'iframe et des cookies en production, afin que le code que vous écrivez fonctionne de la même manière sur `localhost` et en production. Consultez le [guide du proxy de développement](https://docs.whop.com/fr/developer/guides/dev-proxy.md) pour la configuration.

## Vérifier l'accès

Maintenant que vous savez qui envoie la requête, vérifiez ce que cette personne est autorisée à voir. Utilisez la méthode [`checkAccess`](https://docs.whop.com/fr/api-reference/users/check-user-access) pour vérifier l'accès à une Experience, un Account ou un Product.

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

### ID de ressource et niveaux d'accès

| Préfixe de `resource_id` | Vérifie l'accès à |
| - | - |
| `biz_xxxx` | Compte |
| `prod_xxxx` | Produit |
| `exp_xxxx` | Expérience |

Le champ `access_level` de la réponse prend l'une des valeurs suivantes :

| Niveau | Signification |
| - | - |
| `customer` | L'utilisateur dispose d'une adhésion valide. Pour une expérience, il possède une adhésion à l'un des produits qui y sont connectés. Pour un produit, à ce produit précis. Pour un compte, à l'un de ses produits. |
| `admin` | L'utilisateur est membre de l'équipe du compte (quel que soit son rôle, y compris modérateur). |
| `no_access` | L'utilisateur n'a pas accès (`has_access` vaut `false`). |

### Application client (vue Experience)

Les applications client doivent contrôler l'accès à partir de l'`experienceId` transmis dans les paramètres de chemin. Renvoyez `no_access` ou effectuez une redirection si l'utilisateur ne dispose pas d'une adhésion valide.

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

Le même modèle fonctionne dans une route API. Remplacez `headers()` par `request.headers` et renvoyez une `403 Response` au lieu du JSX.

### Application Dashboard (vue Dashboard)

Les applications Dashboard doivent contrôler l'accès avec `access_level === "admin"` afin que seuls les membres de l'équipe du compte puissent charger la vue.

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

Même modèle dans une route API. Remplacez `headers()` par `request.headers` et renvoyez une `403 Response` au lieu du JSX.

## Étapes suivantes

> [card] [Exécuter un proxy de développement local](https://docs.whop.com/fr/developer/guides/dev-proxy.md)
>
> Reproduisez la configuration iframe et cookies de production sur localhost.

> [card] [Demander des permissions](https://docs.whop.com/fr/developer/guides/permissions.md)
>
> Ajoutez les scopes dont votre application a besoin avant de la publier.

> [card] [Écouter les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Recevez sur votre serveur les événements de paiement, d'adhésion et d'inscription.

> [card] [Créer une vue d'application](https://docs.whop.com/fr/developer/guides/app-views.md)
>
> Configurez les vues Dashboard, les expériences et les fiches de découverte.


## Related topics

- [Créer des applications Whop](https://docs.whop.com/fr/developer/apps/overview.md)
- [Activer les versements des sous-comptes](https://docs.whop.com/fr/developer/platforms/render-payout-portal.md)
- [Dépanner les intégrations Whop](https://docs.whop.com/fr/developer/troubleshooting.md)
