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

# Adhésions

> Consultez les adhésions et modifiez leur facturation avec l'API, par exemple pour mettre en pause un abonnement ou ajouter des jours gratuits.

Une adhésion (Membership) est la relation active entre un utilisateur et un produit. Elle suit l'accès, le statut de facturation et le calendrier de renouvellement. Vous ne créez pas les adhésions directement, car le checkout s'en charge pour vous. Une fois qu'une adhésion existe, vous pouvez la consulter, mettre en pause ou annuler la facturation, offrir du temps gratuit ou mettre à jour les métadonnées.

> [!TIP]
>
> La plupart des apps n'ont pas du tout besoin de gérer les adhésions. Utilisez ces méthodes lorsque vous créez des outils d'administration, des parcours de support client ou des tableaux de bord en libre-service permettant aux utilisateurs de mettre en pause ou d'annuler.

## Le cycle de vie en un coup d'œil

| Action | Méthode | Ce qu'elle fait |
| - | - | - |
| Mettre la facturation en pause | [`memberships.pause`](https://docs.whop.com/fr/api-reference/memberships/pause-membership) | Arrête les renouvellements futurs jusqu'à la reprise. L'accès existant est conservé. |
| Reprendre la facturation | [`memberships.resume`](https://docs.whop.com/fr/api-reference/memberships/resume-membership) | Annule une mise en pause. |
| Annuler | [`memberships.cancel`](https://docs.whop.com/fr/api-reference/memberships/cancel-membership) | En fin de période, ou immédiatement (par défaut). |
| Rétablir après une annulation | [`memberships.update`](https://docs.whop.com/fr/api-reference/memberships/update-membership) | Envoyez `cancel_at_period_end: false` pour annuler une résiliation en attente. |
| Offrir du temps | [`memberships.extend`](https://docs.whop.com/fr/api-reference/memberships/extend-membership) | Repousse la prochaine date de renouvellement de N jours. |
| Changer le jour de facturation | [`memberships.update`](https://docs.whop.com/fr/api-reference/memberships/update-membership) | Envoyez `current_period_end` pour déplacer le prochain renouvellement. Les adhésions facturées tous les 30, 60, 90 … 360 ou 365 jours continuent de se renouveler ce jour-là du mois. |
| Mettre à jour les métadonnées | [`memberships.update`](https://docs.whop.com/fr/api-reference/memberships/update-membership) | Modifie les métadonnées ou d'autres champs modifiables. |

## Récupérer et lister

```typescript TypeScript theme={null}
const membership = await client.memberships.retrieve({ id: "mem_xxxxxxxxxxxxx" });

// List with auto-pagination
const memberships = await client.memberships.list({
  account_id: "biz_xxxxxxxxxxxxx",
});

for await (const item of memberships) {
  console.log(item);
}
```

```python Python theme={null}
membership = client.memberships.retrieve("mem_xxxxxxxxxxxxx")

for item in client.memberships.list(account_id="biz_xxxxxxxxxxxxx"):
    print(item)
```

```ruby Ruby theme={null}
membership = client.memberships.retrieve(id: "mem_xxxxxxxxxxxxx")

# list returns an Enumerable that pages for you and yields one membership at a time
client.memberships.list(account_id: "biz_xxxxxxxxxxxxx").each do |item|
  puts item
end
```

```rust Rust theme={null}
let membership = client
    .memberships
    .retrieve(&"mem_xxxxxxxxxxxxx".to_string(), None)
    .await?;

// List one page of memberships for an account
let memberships = client
    .memberships
    .list(
        &MembershipsListQueryRequest {
            account_id: Some("biz_xxxxxxxxxxxxx".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

for item in memberships.data {
    println!("{item:?}");
}
```

```go Go theme={null}
membership, err := client.Memberships.Retrieve(context.TODO(), &whopsdk.RetrieveMembershipsRequest{
    ID: "mem_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(membership)

// List with auto-pagination
page, err := client.Memberships.List(context.TODO(), &whopsdk.ListMembershipsRequest{
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxx"),
})
if err != nil {
    log.Fatal(err)
}

iter := page.Iterator()
for iter.Next(context.TODO()) {
    fmt.Println(iter.Current())
}
if err := iter.Err(); err != nil {
    log.Fatal(err)
}
```

## Mettre en pause et reprendre

La mise en pause arrête le prochain cycle de facturation. L'utilisateur conserve son accès actuel jusqu'à la fin de la période en cours, mais le renouvellement ne se déclenche pas. Passez `until` pour planifier une reprise automatique.

```typescript TypeScript theme={null}
await client.memberships.pause({
  id: "mem_xxxxxxxxxxxxx",
  until: "2026-09-01T00:00:00Z", // optional, resumes automatically
});

// Later
await client.memberships.resume({ id: "mem_xxxxxxxxxxxxx" });
```

```python Python theme={null}
client.memberships.pause(
    "mem_xxxxxxxxxxxxx",
    until="2026-09-01T00:00:00Z",  # optional, resumes automatically
)

client.memberships.resume("mem_xxxxxxxxxxxxx")
```

```ruby Ruby theme={null}
client.memberships.pause(
  id: "mem_xxxxxxxxxxxxx",
  until: "2026-09-01T00:00:00Z", # optional, resumes automatically
)

# Later
client.memberships.resume(id: "mem_xxxxxxxxxxxxx")
```

```rust Rust theme={null}
client
    .memberships
    .pause(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &PauseMembershipsRequest {
            until: Some("2026-09-01T00:00:00Z".to_string()), // optional, resumes automatically
        },
        None,
    )
    .await?;

// Later
client.memberships.resume(&"mem_xxxxxxxxxxxxx".to_string(), None).await?;
```

```go Go theme={null}
_, err := client.Memberships.Pause(context.TODO(), &whopsdk.PauseMembershipsRequest{
    ID:    "mem_xxxxxxxxxxxxx",
    Until: whopsdk.String("2026-09-01T00:00:00Z"), // optional, resumes automatically
})
if err != nil {
    log.Fatal(err)
}

// Later
if _, err := client.Memberships.Resume(context.TODO(), &whopsdk.ResumeMembershipsRequest{
    ID: "mem_xxxxxxxxxxxxx",
}); err != nil {
    log.Fatal(err)
}
```

## Annuler

Deux modes d'annulation. `cancel_at_period_end: true` conserve l'accès jusqu'à la date de renouvellement actuelle, puis désactive l'adhésion. Omettez-le (ou passez `false`) pour révoquer l'accès immédiatement.

```typescript TypeScript theme={null}
// Cancel at the end of the current billing period
await client.memberships.cancel({
  id: "mem_xxxxxxxxxxxxx",
  cancel_at_period_end: true,
});

// Cancel immediately. Access ends now.
await client.memberships.cancel({
  id: "mem_xxxxxxxxxxxxx",
  cancel_at_period_end: false,
  reason: "Requested by customer",
});
```

```python Python theme={null}
# Cancel at the end of the current billing period
client.memberships.cancel(
    "mem_xxxxxxxxxxxxx",
    cancel_at_period_end=True,
)

# Cancel immediately. Access ends now.
client.memberships.cancel(
    "mem_xxxxxxxxxxxxx",
    cancel_at_period_end=False,
    reason="Requested by customer",
)
```

```ruby Ruby theme={null}
# Cancel at the end of the current billing period
client.memberships.cancel(
  id: "mem_xxxxxxxxxxxxx",
  cancel_at_period_end: true,
)

# Cancel immediately. Access ends now.
client.memberships.cancel(
  id: "mem_xxxxxxxxxxxxx",
  cancel_at_period_end: false,
  reason: "Requested by customer",
)
```

```rust Rust theme={null}
// Cancel at the end of the current billing period
client
    .memberships
    .cancel(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &CancelMembershipsRequest {
            cancel_at_period_end: Some(true),
            ..Default::default()
        },
        None,
    )
    .await?;

// Cancel immediately. Access ends now.
client
    .memberships
    .cancel(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &CancelMembershipsRequest {
            cancel_at_period_end: Some(false),
            reason: Some("Requested by customer".to_string()),
        },
        None,
    )
    .await?;
```

```go Go theme={null}
// Cancel at the end of the current billing period
_, err := client.Memberships.Cancel(context.TODO(), &whopsdk.CancelMembershipsRequest{
    ID:                "mem_xxxxxxxxxxxxx",
    CancelAtPeriodEnd: whopsdk.Bool(true),
})
if err != nil {
    log.Fatal(err)
}

// Cancel immediately. Access ends now.
_, err = client.Memberships.Cancel(context.TODO(), &whopsdk.CancelMembershipsRequest{
    ID:                "mem_xxxxxxxxxxxxx",
    CancelAtPeriodEnd: whopsdk.Bool(false),
    Reason:            whopsdk.String("Requested by customer"),
})
if err != nil {
    log.Fatal(err)
}
```

> [!NOTE]
>
> `cancel_at_period_end: true` passe `cancel_at_period_end` à `true` sur l'adhésion. L'utilisateur conserve l'accès jusqu'au renouvellement, puis l'adhésion est désactivée et `membership.updated` est déclenché avec `previous_attributes.status` défini sur le statut précédent. Omettre le champ révoque l'accès immédiatement : envoyez-le donc explicitement chaque fois que vous souhaitez annuler en fin de période.

## Rétablir une adhésion annulée

Si l'utilisateur change d'avis avant la fin de la période, supprimez l'annulation de fin de période en attente avec une mise à jour. Sans effet si l'annulation de l'adhésion n'était pas planifiée.

```typescript TypeScript theme={null}
await client.memberships.update({
  id: "mem_xxxxxxxxxxxxx",
  cancel_at_period_end: false,
});
```

```python Python theme={null}
client.memberships.update("mem_xxxxxxxxxxxxx", cancel_at_period_end=False)
```

```ruby Ruby theme={null}
client.memberships.update(id: "mem_xxxxxxxxxxxxx", cancel_at_period_end: false)
```

```rust Rust theme={null}
client
    .memberships
    .update(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &UpdateMembershipsRequest {
            cancel_at_period_end: Some(false),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
if _, err := client.Memberships.Update(context.TODO(), &whopsdk.UpdateMembershipsRequest{
    ID:                "mem_xxxxxxxxxxxxx",
    CancelAtPeriodEnd: whopsdk.Bool(false),
}); err != nil {
    log.Fatal(err)
}
```

## Ajouter des jours gratuits

Offrez à l'utilisateur du temps supplémentaire sur sa période en cours. La prochaine date de renouvellement est repoussée de `days`. Utile en cas d'interruption de service, de geste commercial du support ou de récompense de parrainage.

```typescript TypeScript theme={null}
await client.memberships.extend({
  id: "mem_xxxxxxxxxxxxx",
  days: 7,
});
```

```python Python theme={null}
client.memberships.extend("mem_xxxxxxxxxxxxx", days=7)
```

```ruby Ruby theme={null}
client.memberships.extend(id: "mem_xxxxxxxxxxxxx", days: 7)
```

```rust Rust theme={null}
client
    .memberships
    .extend(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &ExtendMembershipsRequest { days: 7 },
        None,
    )
    .await?;
```

```go Go theme={null}
if _, err := client.Memberships.Extend(context.TODO(), &whopsdk.ExtendMembershipsRequest{
    ID:   "mem_xxxxxxxxxxxxx",
    Days: 7,
}); err != nil {
    log.Fatal(err)
}
```

`days` accepte une valeur de 1 à 1095 (3 ans).

## Mettre à jour les métadonnées

Modifiez des métadonnées arbitraires ou d'autres champs modifiables de l'adhésion.

```typescript TypeScript theme={null}
await client.memberships.update({
  id: "mem_xxxxxxxxxxxxx",
  metadata: { internal_user_id: "user_12345", tier: "gold" },
});
```

```python Python theme={null}
client.memberships.update(
    "mem_xxxxxxxxxxxxx",
    metadata={"internal_user_id": "user_12345", "tier": "gold"},
)
```

```ruby Ruby theme={null}
client.memberships.update(
  id: "mem_xxxxxxxxxxxxx",
  metadata: { internal_user_id: "user_12345", tier: "gold" },
)
```

```rust Rust theme={null}
client
    .memberships
    .update(
        &"mem_xxxxxxxxxxxxx".to_string(),
        &UpdateMembershipsRequest {
            metadata: Some(HashMap::from([
                ("internal_user_id".to_string(), json!("user_12345")),
                ("tier".to_string(), json!("gold")),
            ])),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
if _, err := client.Memberships.Update(context.TODO(), &whopsdk.UpdateMembershipsRequest{
    ID: "mem_xxxxxxxxxxxxx",
    Metadata: map[string]any{
        "internal_user_id": "user_12345",
        "tier":             "gold",
    },
}); err != nil {
    log.Fatal(err)
}
```

## Écouter les événements du cycle de vie

Abonnez-vous via les [webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md). Voici les événements déclenchés tout au long du cycle de vie :

| Événement | Quand il est déclenché |
| - | - |
| [`membership.activated`](https://docs.whop.com/fr/api-reference/memberships/membership-activated) | L'adhésion devient valide (l'achat initial ou le paiement de renouvellement réussit). |
| [`membership.updated`](https://docs.whop.com/fr/api-reference/memberships/membership-updated) | Quelque chose a changé sur l'adhésion. Elle est devenue invalide (paiement échoué, annulation immédiate, annulation de fin de période effective, ou départ de l'utilisateur). L'utilisateur a activé ou désactivé l'annulation. Le vendeur a modifié la période de facturation, le prix ou la date de renouvellement. `previous_attributes` contient les valeurs d'avant le changement. Les activations sont aussi envoyées sous forme de `membership.updated`. |

Pour `pause` / `resume` / `extend`, le statut de l'adhésion ne change pas, donc aucun événement d'activation/désactivation n'est déclenché. Si vous devez confirmer que la modification a réussi, récupérez l'adhésion après l'appel ou interrogez-la selon votre propre calendrier.

## Étapes suivantes

> [card] [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
>
> L'origine des adhésions. Checkouts ponctuels et récurrents.

> [card] [Enregistrer des moyens de paiement](https://docs.whop.com/fr/developer/guides/save-payment-methods.md)
>
> Cartes enregistrées pour les renouvellements futurs et la facturation hors session.

> [card] [Écouter les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Réagissez aux activations, désactivations et changements d'annulation.

> [card] [Référence API des adhésions](https://docs.whop.com/fr/api-reference/memberships/membership)
>
> La ressource complète : champs, statuts et tous les endpoints.


## Related topics

- [Adhésion](https://docs.whop.com/fr/api-reference/legacy/memberships/membership.md)
- [Vérifier les droits d'accès](https://docs.whop.com/fr/developer/guides/ios/check-entitlements.md)
- [Migrer depuis les versions précédentes](https://docs.whop.com/fr/developer/api/migrate-from-previous-versions.md)
