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

> Vendez votre logiciel sur Whop. Protégez une application web en vérifiant l'accès de chaque utilisateur, ou protégez un logiciel téléchargeable avec des clés de licence.

Whop gère le checkout, la facturation et la gestion des abonnements de votre logiciel. Avant que votre app ne laisse entrer quelqu'un, elle vérifie auprès de Whop que le client a bien accès à ce moment-là. Cette page présente les deux façons d'effectuer cette vérification.

## Choisissez votre intégration

| | Vérification d'accès | Clés de licence |
| - | - | - |
| **Idéal pour** | Une application web où les utilisateurs se connectent à votre site | Les applications de bureau, scripts et outils que les utilisateurs téléchargent |
| **Ce qui identifie le client** | Son ID utilisateur Whop, stocké dans votre fiche utilisateur | Une clé de licence émise par Whop à chaque achat |
| **Ce que votre serveur appelle** | `users.checkAccess` | `memberships.retrieve` et `memberships.update` |
| **Limitation à une seule machine** | Non | Oui, avec un identifiant matériel dans les métadonnées de l'abonnement |

Les deux approches partagent la même configuration.

## Configuration

### 1. Créez votre whop et un produit

Commencez sur [whop.com/sell](https://whop.com/dashboard/start/) pour nommer votre whop et choisir son URL. Rendez-vous ensuite dans **Products** dans votre tableau de bord et ajoutez un produit avec le prix que paient vos clients. Copiez l'ID du produit (`prod_`) et l'ID de son plan (`plan_`). Vous aurez besoin des deux ci-dessous.

### 2. Créez une clé API

Dans votre tableau de bord, accédez à **Developer → API keys** et créez une clé API de compte. Elle agit au nom de votre entreprise : conservez-la donc sur votre serveur et ne l'incluez jamais dans du code client ou dans une app téléchargeable. Stockez-la dans `WHOP_API_KEY`.

### 3. Installez le SDK

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

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

Créez un client unique et réutilisez-le. Les exemples de cette page l'appellent `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"])
```

## Intégration avec connexion par e-mail

Utilisez cette approche lorsque les clients se connectent à votre propre application web. Stockez l'ID utilisateur Whop de chaque client dans votre fiche utilisateur, puis utilisez-le pour vérifier l'accès avant de fournir les fonctionnalités payantes.

### 1. Ajoutez des colonnes Whop à votre table d'utilisateurs

| Colonne | Type | Description |
| - | - | - |
| `whop_user_id` | string | L'ID utilisateur Whop du client, préfixé par `user_`. |
| `whop_username` | string | Facultatif. Le nom d'utilisateur Whop du client. Affichez-le dans votre interface et vos logs. |

### 2. Envoyez les utilisateurs connectés vers le checkout

Créez une configuration de checkout depuis votre serveur et placez votre propre ID utilisateur dans `metadata`. Whop copie ces métadonnées sur l'abonnement, ce qui permet à l'étape suivante de relier l'achat à votre utilisateur. Redirigez ensuite l'utilisateur vers `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
```

Pour garder plutôt les acheteurs sur votre propre page, [intégrez l'élément Checkout](https://docs.whop.com/fr/developer/guides/embed-checkout.md) et passez les mêmes `metadata` sur son handle. [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md) compare toutes les options de checkout.

### 3. Enregistrez l'ID utilisateur Whop à partir du webhook

Ouvrez l'[onglet Developer de votre tableau de bord](https://whop.com/dashboard/developer), sélectionnez **Create webhook**, abonnez-vous à `membership.activated` et stockez le secret de signature dans `WHOP_WEBHOOK_SECRET`. Le champ `data` de l'événement est l'abonnement, avec le `user_id` de l'acheteur et les `metadata` que vous avez définies lors du 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` se déclenche aussi lors des renouvellements : assurez-vous donc que l'écriture peut être répétée sans risque. [Webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) couvre les nouvelles tentatives et les tests.

### 4. Vérifiez l'accès avant de fournir les fonctionnalités payantes

Demandez à Whop si l'utilisateur a accès à votre produit. La réponse tient compte des renouvellements, des annulations et des remboursements : vous n'avez donc pas besoin de suivre vous-même l'état de la facturation.

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

Dans la même réponse, `access_level` vaut `customer`, `admin` ou `no_access`.

### 5. Laissez les clients gérer leur facturation

Renvoyez les clients vers leurs [commandes Whop](https://whop.com/@me/settings/orders) pour mettre à jour leur moyen de paiement ou annuler. Ils se connectent avec l'e-mail utilisé lors de l'achat.

## Intégration par clé de licence

Utilisez cette approche pour les logiciels qui s'exécutent sur la machine du client. Chaque achat s'accompagne d'une clé de licence unique. Votre logiciel demande la clé, et votre serveur la vérifie auprès de Whop.

### 1. Ajoutez l'app Software à votre produit

[Installez l'app Software](https://whop.com/apps/app_jHH5YT7jHYQANi/install/) sur votre whop, ouvrez-la et ajoutez le nom de votre logiciel ainsi que son lien de téléchargement. Les acheteurs voient alors leur clé de licence et le téléchargement dans leurs commandes. L'API ne renvoie le `license_key` d'un abonnement que lorsque son produit inclut cette app.

### 2. Validez les clés depuis votre serveur

Vérifiez les clés depuis votre propre serveur, jamais depuis le logiciel que vous distribuez. Votre clé API peut lire et modifier tous les abonnements de votre entreprise : ne l'intégrez donc jamais dans une application de bureau ou un script téléchargé par les utilisateurs. Votre logiciel envoie la clé de licence et un identifiant de machine à votre serveur, et votre serveur la vérifie auprès de Whop.

Pour limiter chaque clé à une seule machine, stockez un identifiant matériel dans les métadonnées de l'abonnement la première fois que quelqu'un utilise la clé, puis comparez-le à chaque vérification ultérieure :

* **La clé n'est pas encore liée** (pas de `hwid` dans ses métadonnées) : enregistrez le `hwid` de la machine et accordez l'accès.
* **Le `hwid` stocké correspond :** accordez l'accès.
* **Le `hwid` stocké est différent :** refusez l'accès. La clé est utilisée sur une autre machine jusqu'à ce que le client la réinitialise.

```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. Réinitialisez une clé de licence

Les clients peuvent réinitialiser leur clé depuis leurs commandes. Pour la réinitialiser depuis votre serveur, [mettez à jour l'abonnement](https://docs.whop.com/fr/api-reference/memberships/update-membership.md) avec un objet de métadonnées vide (`metadata: {}`). La vérification suivante, depuis n'importe quelle machine, lie de nouveau la clé.

## Concevez votre page boutique

Votre page boutique est l'endroit où les gens découvrent votre logiciel avant de l'acheter. Sélectionnez le nom de votre whop en haut à gauche, puis sélectionnez **Design store page** pour ouvrir l'éditeur. Sélectionnez **Edit details** pour personnaliser :

* **Nom et titre :** indiquez ce que fait le logiciel et à qui il s'adresse.
* **Description :** mettez l'accent sur le problème qu'il résout et sur ce que les acheteurs obtiennent, comme des mises à jour, de l'assistance ou une communauté.
* **Logo :** ajoutez un logo simple et soigné.
* **Images ou vidéo de la galerie :** montrez le logiciel en action. Une courte vidéo de démonstration aide les acheteurs à se décider.
* **Catégorie :** choisissez la catégorie qui aide les gens à trouver votre logiciel lorsqu'ils parcourent Whop.

## Étapes suivantes

> [card] [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
>
> Comparez les liens de checkout, l'élément Checkout et les payment elements.

> [card] [Webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Vérifiez les signatures, gérez les nouvelles tentatives et testez les événements.

> [card] [Gérer les abonnements](https://docs.whop.com/fr/developer/guides/memberships.md)
>
> Annulez, suspendez, prolongez et mettez à jour les abonnements depuis votre serveur.

> [card] [Se connecter avec Whop](https://docs.whop.com/fr/developer/guides/oauth.md)
>
> Permettez aux clients de se connecter avec leur compte Whop plutôt qu'avec un mot de passe.


## Related topics

- [Bien démarrer avec Whop](https://docs.whop.com/fr/get-started.md)
- [Que sont les apps Whop](https://docs.whop.com/fr/whop-apps/what-are-whop-apps.md)
