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

# Affiliés

> Créez des fiches d'affiliés, attribuez des commissions spécifiques par variante ou en partage de revenus, et suivez les gains issus des parrainages.

Les affiliés perçoivent des commissions sur les ventes qu'ils apportent. Le flux de l'API comporte deux parties : créer une fiche d'affilié, puis ajouter des règles spécifiques (overrides) qui définissent la commission.

## Fonctionnement de l'attribution

1. Vous créez une fiche d'affilié pour un utilisateur, puis vous ajoutez des overrides. Chaque override renvoie les champs `product_direct_link` et `checkout_direct_link`. Ce sont les URL de parrainage que l'affilié partage (elles contiennent `?a=<username>`).
2. Un acheteur utilise le lien. Whop enregistre le cookie d'affiliation (fenêtre d'attribution de 30 jours par défaut).
3. L'acheteur passe commande pendant cette fenêtre. L'override correspondant calcule la commission : `standard` (par variante, en pourcentage ou en montant fixe) ou `rev_share` (pourcentage du chiffre d'affaires, pour un produit précis ou pour tout le compte).
4. Whop attribue la commission à l'affilié et la reflète dans le champ `total_referral_earnings_usd` de l'override.

> [!NOTE]
>
> **Les remboursements annulent les commissions.** Si un acheteur est remboursé pendant la fenêtre, le gain de l'affilié sur cette vente est automatiquement récupéré.

> [!NOTE]
>
> **Les affiliés ont besoin d'un compte Whop pour recevoir leurs versements.** Les gains s'accumulent sur la fiche. Les versements sont crédités sur le solde de leur compte via des [transferts](https://docs.whop.com/fr/developer/platforms/collect-payments-for-subaccounts.md#transfers). S'ils n'ont pas encore de compte, intégrez-les via l'[inscription de sous-comptes](https://docs.whop.com/fr/developer/platforms/enroll-subaccounts.md).

## Créer un affilié

`user_identifier` se résout de manière flexible. Transmettez un nom d'utilisateur, une adresse e-mail, un ID utilisateur ou un ID Discord. Si une fiche d'affilié existe déjà pour la paire compte/utilisateur, Whop renvoie la fiche existante (idempotent).

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

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

const affiliate = await client.affiliates.create({
  account_id: "biz_xxxxxxxxxxxxx",
  user_identifier: "johndoe", // username, email, usr_xxx, or Discord ID
});

console.log(`Affiliate ${affiliate.id} created`);
```

```python Python theme={null}
import os
from whop_sdk import Whop

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

affiliate = client.affiliates.create(
    account_id="biz_xxxxxxxxxxxxx",
    user_identifier="johndoe",
)

print(f"Affiliate {affiliate.id} created")
```

```rust Rust theme={null}
use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some(std::env::var("WHOP_API_KEY").unwrap()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let affiliate = client
    .affiliates
    .create(
        &CreateAffiliatesRequest {
            account_id: "biz_xxxxxxxxxxxxx".to_string(),
            user_identifier: "johndoe".to_string(), // username, email, usr_xxx, or Discord ID
        },
        None,
    )
    .await?;

println!("Affiliate {} created", affiliate.id);
```

```go Go theme={null}
import (
    "context"
    "fmt"
    "log"
    "os"

    whopsdk "github.com/whopio/whopsdk-go/v2"
    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken(os.Getenv("WHOP_API_KEY")))

affiliate, err := client.Affiliates.Create(context.TODO(), &whopsdk.CreateAffiliatesRequest{
    AccountID:      "biz_xxxxxxxxxxxxx",
    UserIdentifier: "johndoe", // username, email, usr_xxx, or Discord ID
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Affiliate %s created\n", affiliate.ID)
```

## Ajouter des overrides de commission

Une fiche d'affilié ne définit pas de commission à elle seule. Ajoutez des **overrides** pour déterminer la rémunération de l'affilié.

| Type d'override | Rôle | Champs obligatoires |
| - | - | - |
| **`standard`** | Commission par variante, en pourcentage ou en montant fixe | `plan_id`, `commission_type`, `commission_value`, `applies_to_payments` |
| **`rev_share`** | Partage de revenus en pourcentage, pour un produit précis ou pour tout le compte | `commission_value` (toujours en pourcentage) et `product_id` facultatif |

### Standard (par variante)

```typescript TypeScript theme={null}
const override = await client.affiliates.overrides.create({
  id: affiliate.id,
  body: {
    id: affiliate.id,
    override_type: "standard",
    plan_id: "plan_xxxxxxxxxxxxx",
    commission_type: "percentage",       // "percentage" or "flat_fee"
    commission_value: 40,                // 40% (or $40 if flat_fee)
    applies_to_payments: "first_payment" // "first_payment" or "all_payments"
  },
});

// Share these with the affiliate
console.log(override.product_direct_link);
console.log(override.checkout_direct_link);
```

```python Python theme={null}
override = client.affiliates.overrides.create(
    affiliate.id,
    request={
        "override_type": "standard",
        "plan_id": "plan_xxxxxxxxxxxxx",
        "commission_type": "percentage",   # "percentage" or "flat_fee"
        "commission_value": 40,            # 40% (or $40 if flat_fee)
        "applies_to_payments": "first_payment",
    },
)

print(override.product_direct_link)
print(override.checkout_direct_link)
```

```rust Rust theme={null}
let created = client
    .affiliates
    .overrides
    .create(
        &"aff_xxxxxxxxxxxxx".to_string(),
        // (applies_to_payments, commission_type, commission_value, affiliate_id, plan_id)
        &CreateOverridesRequestBody::standard_with_commission_type(
            Some(AffiliateAppliesToPayments::FirstPayment),
            AffiliatePayoutTypes::Percentage, // percentage or flat_fee
            40.0,                             // 40% (or $40 if flat_fee)
            "aff_xxxxxxxxxxxxx".to_string(),
            "plan_xxxxxxxxxxxxx".to_string(),
        ),
        None,
    )
    .await?;

// Share these with the affiliate
println!("{:?}", created.product_direct_link);
println!("{:?}", created.checkout_direct_link);
```

```go Go theme={null}
created, err := client.Affiliates.Overrides.Create(context.TODO(), &affiliates.CreateOverridesRequest{
    ID: "aff_xxxxxxxxxxxxx",
    Body: &affiliates.CreateOverridesRequestBody{
        Standard: &affiliates.CreateOverridesRequestBodyStandard{
            ID:                "aff_xxxxxxxxxxxxx",
            PlanID:            "plan_xxxxxxxxxxxxx",
            CommissionType:    whopsdk.AffiliatePayoutTypesPercentage.Ptr(), // percentage or flat_fee
            CommissionValue:   40,                                           // 40% (or $40 if flat_fee)
            AppliesToPayments: whopsdk.AffiliateAppliesToPaymentsFirstPayment.Ptr(),
        },
    },
})
if err != nil {
    log.Fatal(err)
}

// Share these with the affiliate
fmt.Println(*created.ProductDirectLink)
fmt.Println(*created.CheckoutDirectLink)
```

Règles de `commission_value` :

* `"percentage"` : nombre entier de 1 à 100 (`40` = 40 %).
* `"flat_fee"` : montant en dollars (`10` = 10 \$).

`applies_to_payments` :

* `"first_payment"` : l'affilié est rémunéré uniquement sur l'achat initial.
* `"all_payments"` : l'affilié est aussi rémunéré sur chaque paiement récurrent.

### Rev-share (pourcentage du chiffre d'affaires)

Les overrides de partage de revenus sont toujours exprimés en pourcentage. Ne transmettez pas `commission_type: "flat_fee"`.

```typescript TypeScript theme={null}
// Product-specific: affiliate earns 30% on sales of this product
await client.affiliates.overrides.create({
  id: affiliate.id,
  body: {
    id: affiliate.id,
    override_type: "rev_share",
    product_id: "prod_xxxxxxxxxxxxx",
    commission_value: 30,
  },
});

// Account-wide: affiliate earns 15% on every product
await client.affiliates.overrides.create({
  id: affiliate.id,
  body: {
    id: affiliate.id,
    override_type: "rev_share",
    commission_value: 15,
  },
});
```

```python Python theme={null}
# Product-specific: affiliate earns 30% on sales of this product
client.affiliates.overrides.create(
    affiliate.id,
    request={
        "override_type": "rev_share",
        "product_id": "prod_xxxxxxxxxxxxx",
        "commission_value": 30,
    },
)

# Account-wide: affiliate earns 15% on every product
client.affiliates.overrides.create(
    affiliate.id,
    request={
        "override_type": "rev_share",
        "commission_value": 15,
    },
)
```

```rust Rust theme={null}
// Product-specific: affiliate earns 30% on sales of this product
client
    .affiliates
    .overrides
    .create(
        &"aff_xxxxxxxxxxxxx".to_string(),
        // (commission_type, commission_value, affiliate_id, product_id, revenue_basis)
        &CreateOverridesRequestBody::rev_share_with_product_id(
            None,
            30.0,
            "aff_xxxxxxxxxxxxx".to_string(),
            "prod_xxxxxxxxxxxxx".to_string(),
            None,
        ),
        None,
    )
    .await?;

// Account-wide: affiliate earns 15% on every product
client
    .affiliates
    .overrides
    .create(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &CreateOverridesRequestBody::rev_share(15.0, "aff_xxxxxxxxxxxxx".to_string()),
        None,
    )
    .await?;
```

```go Go theme={null}
// Product-specific: affiliate earns 30% on sales of this product
_, err := client.Affiliates.Overrides.Create(context.TODO(), &affiliates.CreateOverridesRequest{
    ID: "aff_xxxxxxxxxxxxx",
    Body: &affiliates.CreateOverridesRequestBody{
        RevShare: &affiliates.CreateOverridesRequestBodyRevShare{
            ID:              "aff_xxxxxxxxxxxxx",
            ProductID:       whopsdk.String("prod_xxxxxxxxxxxxx"),
            CommissionValue: 30,
        },
    },
})
if err != nil {
    log.Fatal(err)
}

// Account-wide: affiliate earns 15% on every product
_, err = client.Affiliates.Overrides.Create(context.TODO(), &affiliates.CreateOverridesRequest{
    ID: "aff_xxxxxxxxxxxxx",
    Body: &affiliates.CreateOverridesRequestBody{
        RevShare: &affiliates.CreateOverridesRequestBodyRevShare{
            ID:              "aff_xxxxxxxxxxxxx",
            CommissionValue: 15,
        },
    },
})
if err != nil {
    log.Fatal(err)
}
```

## Gérer les overrides

```typescript TypeScript theme={null}
// List all overrides for an affiliate
const overrides = await client.affiliates.overrides.list({ id: "aff_xxxxxxxxxxxxx" });

// Filter by type
const standardOnly = await client.affiliates.overrides.list({
  id: "aff_xxxxxxxxxxxxx",
  override_type: "standard",
});

// Retrieve one
const o = await client.affiliates.overrides.retrieve({
  id: "aff_xxxxxxxxxxxxx",
  override_id: "aovr_xxxxxxxxxxxxx",
});

// Update
await client.affiliates.overrides.update({
  id: "aff_xxxxxxxxxxxxx",
  override_id: "aovr_xxxxxxxxxxxxx",
  commission_value: 50,
  applies_to_payments: "all_payments",
});

// Delete (for standard overrides, this also removes the affiliate from that variant)
await client.affiliates.overrides.delete({
  id: "aff_xxxxxxxxxxxxx",
  override_id: "aovr_xxxxxxxxxxxxx",
});
```

```python Python theme={null}
# List all overrides for an affiliate
overrides = client.affiliates.overrides.list("aff_xxxxxxxxxxxxx")

# Filter by type
standard_only = client.affiliates.overrides.list(
    "aff_xxxxxxxxxxxxx",
    override_type="standard",
)

# Retrieve one
o = client.affiliates.overrides.retrieve("aff_xxxxxxxxxxxxx", "aovr_xxxxxxxxxxxxx")

# Update
client.affiliates.overrides.update(
    "aff_xxxxxxxxxxxxx",
    "aovr_xxxxxxxxxxxxx",
    commission_value=50,
    applies_to_payments="all_payments",
)

# Delete (for standard overrides, this also removes the affiliate from that variant)
client.affiliates.overrides.delete("aff_xxxxxxxxxxxxx", "aovr_xxxxxxxxxxxxx")
```

```rust Rust theme={null}
// List all overrides for an affiliate
let overrides = client
    .affiliates
    .overrides
    .list(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &AffiliatesOverridesListQueryRequest::default(),
        None,
    )
    .await?;

// Filter by type
let standard_only = client
    .affiliates
    .overrides
    .list(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &AffiliatesOverridesListQueryRequest {
            override_type: Some(AffiliateOverrideRoles::Standard),
            ..Default::default()
        },
        None,
    )
    .await?;

// Retrieve one
let single = client
    .affiliates
    .overrides
    .retrieve(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &"aovr_xxxxxxxxxxxxx".to_string(),
        None,
    )
    .await?;

// Update
client
    .affiliates
    .overrides
    .update(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &"aovr_xxxxxxxxxxxxx".to_string(),
        &UpdateOverridesRequest {
            commission_value: Some(50.0),
            applies_to_payments: Some(AffiliateAppliesToPayments::AllPayments),
            ..Default::default()
        },
        None,
    )
    .await?;

// Delete (for standard overrides, this also removes the affiliate from that variant)
client
    .affiliates
    .overrides
    .delete(
        &"aff_xxxxxxxxxxxxx".to_string(),
        &"aovr_xxxxxxxxxxxxx".to_string(),
        None,
    )
    .await?;
```

```go Go theme={null}
// List all overrides for an affiliate
overridesList, err := client.Affiliates.Overrides.List(context.TODO(), &affiliates.ListOverridesRequest{
    ID: "aff_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
_ = overridesList

// Filter by type
standardOnly, err := client.Affiliates.Overrides.List(context.TODO(), &affiliates.ListOverridesRequest{
    ID:           "aff_xxxxxxxxxxxxx",
    OverrideType: whopsdk.AffiliateOverrideRolesStandard.Ptr(),
})
if err != nil {
    log.Fatal(err)
}
_ = standardOnly

// Retrieve one
single, err := client.Affiliates.Overrides.Retrieve(context.TODO(), &affiliates.RetrieveOverridesRequest{
    ID:         "aff_xxxxxxxxxxxxx",
    OverrideID: "aovr_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
_ = single

// Update
_, err = client.Affiliates.Overrides.Update(context.TODO(), &affiliates.UpdateOverridesRequest{
    ID:                "aff_xxxxxxxxxxxxx",
    OverrideID:        "aovr_xxxxxxxxxxxxx",
    CommissionValue:   whopsdk.Float64(50),
    AppliesToPayments: whopsdk.AffiliateAppliesToPaymentsAllPayments.Ptr(),
})
if err != nil {
    log.Fatal(err)
}

// Delete (for standard overrides, this also removes the affiliate from that variant)
_, err = client.Affiliates.Overrides.Delete(context.TODO(), &affiliates.DeleteOverridesRequest{
    ID:         "aff_xxxxxxxxxxxxx",
    OverrideID: "aovr_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
```

## Gérer les affiliés

```typescript TypeScript theme={null}
// List, optionally filtered by status. The page is async-iterable and
// fetches the next page for you as you consume it.
const affiliates = await client.affiliates.list({
  account_id: "biz_xxxxxxxxxxxxx",
  status: "active",
});

for await (const affiliate of affiliates) {
  console.log(affiliate);
}

const single = await client.affiliates.retrieve({ id: "aff_xxxxxxxxxxxxx" });

// Archive blocks the affiliate from earning further commissions
await client.affiliates.archive({ id: "aff_xxxxxxxxxxxxx" });
await client.affiliates.unarchive({ id: "aff_xxxxxxxxxxxxx" });
```

```python Python theme={null}
# List, optionally filtered by status. Iterating the pager fetches
# the next page for you as you consume it.
for affiliate in client.affiliates.list(
    account_id="biz_xxxxxxxxxxxxx",
    status="active",
):
    print(affiliate)

single = client.affiliates.retrieve("aff_xxxxxxxxxxxxx")

# Archive blocks the affiliate from earning further commissions
client.affiliates.archive("aff_xxxxxxxxxxxxx")
client.affiliates.unarchive("aff_xxxxxxxxxxxxx")
```

```rust Rust theme={null}
// List, optionally filtered by status. Iterate the returned page's `data`.
let affiliates = client
    .affiliates
    .list(
        &AffiliatesListQueryRequest {
            account_id: "biz_xxxxxxxxxxxxx".to_string(),
            status: Some(Status::Active),
            ..Default::default()
        },
        None,
    )
    .await?;

for affiliate in affiliates.data {
    println!("{affiliate:?}");
}

let single = client
    .affiliates
    .retrieve(&"aff_xxxxxxxxxxxxx".to_string(), None)
    .await?;

// Archive blocks the affiliate from earning further commissions
client.affiliates.archive(&"aff_xxxxxxxxxxxxx".to_string(), None).await?;
client.affiliates.unarchive(&"aff_xxxxxxxxxxxxx".to_string(), None).await?;
```

```go Go theme={null}
// List, optionally filtered by status. The page auto-fetches the next page as you iterate.
page, err := client.Affiliates.List(context.TODO(), &whopsdk.ListAffiliatesRequest{
    AccountID: "biz_xxxxxxxxxxxxx",
    Status:    whopsdk.StatusActive.Ptr(),
})
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)
}

single, err := client.Affiliates.Retrieve(context.TODO(), &whopsdk.RetrieveAffiliatesRequest{
    ID: "aff_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
_ = single

// Archive blocks the affiliate from earning further commissions
if _, err := client.Affiliates.Archive(context.TODO(), &whopsdk.ArchiveAffiliatesRequest{ID: "aff_xxxxxxxxxxxxx"}); err != nil {
    log.Fatal(err)
}
if _, err := client.Affiliates.Unarchive(context.TODO(), &whopsdk.UnarchiveAffiliatesRequest{ID: "aff_xxxxxxxxxxxxx"}); err != nil {
    log.Fatal(err)
}
```

## Paramètres d'affiliation au niveau du compte

Trois champs du compte déterminent la façon dont Whop présente le [programme d'affiliation](https://docs.whop.com/fr/manage-your-business/growth-marketing/affiliate-program.md) aux utilisateurs. Mettez-les à jour via la ressource Account.

```typescript TypeScript theme={null}
await client.accounts.update({
  id: "biz_xxxxxxxxxxxxx",
  affiliate_instructions: "Share your link on social. 30-day cookie window.",
  affiliate_application_required: true,
  featured_affiliate_product_id: "prod_xxxxxxxxxxxxx",
});
```

```python Python theme={null}
client.accounts.update(
    "biz_xxxxxxxxxxxxx",
    affiliate_instructions="Share your link on social. 30-day cookie window.",
    affiliate_application_required=True,
    featured_affiliate_product_id="prod_xxxxxxxxxxxxx",
)
```

```rust Rust theme={null}
client
    .accounts
    .update(
        &"biz_xxxxxxxxxxxxx".to_string(),
        &UpdateAccountsRequest {
            affiliate_instructions: Some(
                "Share your link on social. 30-day cookie window.".to_string(),
            ),
            affiliate_application_required: Some(true),
            featured_affiliate_product_id: Some("prod_xxxxxxxxxxxxx".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Accounts.Update(context.TODO(), &whopsdk.UpdateAccountsRequest{
    ID:                           "biz_xxxxxxxxxxxxx",
    AffiliateInstructions:        whopsdk.String("Share your link on social. 30-day cookie window."),
    AffiliateApplicationRequired: whopsdk.Bool(true),
    FeaturedAffiliateProductID:   whopsdk.String("prod_xxxxxxxxxxxxx"),
})
if err != nil {
    log.Fatal(err)
}
```

| Champ | Description |
| - | - |
| `affiliate_instructions` | Consignes affichées aux affiliés qui font la promotion de ce compte |
| `affiliate_application_required` | Indique si les utilisateurs doivent postuler et être approuvés avant de devenir affiliés |
| `featured_affiliate_product_id` | Produit à mettre en avant pour la promotion par les affiliés |

## Suivi des gains

Chaque override comprend un champ `total_referral_earnings_usd` qui reflète les gains cumulés (en dollars américains) pour cet override précis. Récupérez à nouveau l'override (ou listez les overrides d'un affilié) pour obtenir le total actuel.

> [!NOTE]
>
> Il n'existe pas de webhook `affiliate.*` dédié en v1, et le schéma public `payment` n'expose pas le lien avec l'affilié. Interrogez `affiliates.overrides.list` selon votre calendrier de versements et comparez les dernières valeurs de `total_referral_earnings_usd` avec celles que vous avez enregistrées précédemment.

## Champs de réponse d'un override

| Champ | Description |
| - | - |
| `override_type` | `"standard"` ou `"rev_share"` |
| `commission_type` | `"percentage"` ou `"flat_fee"` |
| `commission_value` | Pourcentage (1–100) ou montant fixe en dollars |
| `applies_to_payments` | `"first_payment"` ou `"all_payments"` (standard uniquement, `null` pour rev-share) |
| `plan_id` | ID de la variante, avec le préfixe `plan_` conservé (standard uniquement) |
| `product_id` | ID du produit (rev-share uniquement, `null` si à l'échelle du compte) |
| `applies_to_products` | `"single_product"` ou `"all_products"` (rev-share uniquement) |
| `product_direct_link` | Lien de parrainage vers la page produit (standard uniquement) |
| `checkout_direct_link` | Lien de parrainage vers la page de paiement (standard uniquement) |
| `total_referral_earnings_usd` | Gains cumulés pour cet override |

## Étapes suivantes

> [card] [Verser les gains des affiliés](https://docs.whop.com/fr/developer/platforms/collect-payments-for-subaccounts.md#transfers)
>
> Transférez les commissions accumulées de votre solde vers les comptes des affiliés.

> [card] [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
>
> Les configurations de paiement attribuent automatiquement les ventes lorsque des cookies de parrainage sont définis.

> [card] [Écouter les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Utilisez `payment.succeeded` pour la télémétrie générale des ventes. L'attribution aux affiliés reste basée sur l'interrogation périodique.

> [card] [Référence de l'API Affiliates](https://docs.whop.com/fr/api-reference/legacy/affiliates/affiliate.md)
>
> La ressource complète : endpoints, champs et schémas d'override.


## Related topics

- [API Activité financière](https://docs.whop.com/fr/api-reference/ledgers/ledger-activity.md)
- [API Product Affiliates](https://docs.whop.com/fr/api-reference/product-affiliates/product-affiliate.md)
- [Affilié](https://docs.whop.com/fr/api-reference/legacy/affiliates/affiliate.md)
