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

# Affiliates

> Opret affiliate-poster, tildel provisionsoverrides pr. variant eller som rev-share, og følg indtjening fra henvisninger.

Affiliates tjener provision på henviste salg. API-forløbet består af to dele: Opret en affiliate-post, og tilføj derefter overrides, der definerer provisionen.

## Sådan fungerer attribuering

1. Du opretter en affiliate-post for en bruger og tilføjer derefter overrides. Hver override returnerer felterne `product_direct_link` og `checkout_direct_link`. Det er henvisnings-URL'er, som affiliaten deler (de indeholder `?a=<username>`).
2. En køber bruger linket. Whop gemmer affiliate-cookien (attribueringsvindue på 30 dage som standard).
3. Køberen gennemfører checkout inden for vinduet. Den matchende override beregner provisionen: `standard` (pr. variant, procent eller fast gebyr) eller `rev_share` (procentdel af omsætningen, produktspecifik eller for hele kontoen).
4. Whop tilskriver provisionen til affiliaten og afspejler den i overridens felt `total_referral_earnings_usd`.

> [!NOTE]
>
> **Refusioner tilbagefører provisioner.** Hvis en køber får refusion inden for vinduet, trækkes affiliatens indtjening på det salg automatisk tilbage.

> [!NOTE]
>
> **Affiliates skal have en Whop-konto for at modtage udbetalinger.** Indtjeningen opspares på posten. Udbetalinger går til deres kontosaldo via [overførsler](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md#transfers). Hvis de endnu ikke har en konto, kan du onboarde dem med [tilmelding af underkonti](https://docs.whop.com/da/developer/platforms/enroll-subaccounts.md).

## Opret en affiliate

`user_identifier` opløses fleksibelt. Angiv et brugernavn, en e-mail, et bruger-ID eller et Discord-ID. Hvis der allerede findes en affiliate-post for kombinationen af konto og bruger, returnerer Whop den eksisterende post (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)
```

## Tilføj provisionsoverrides

En affiliate-post definerer ikke en provision i sig selv. Tilføj **overrides** for at bestemme, hvad affiliaten får udbetalt.

| Override-type | Hvad den gør | Påkrævede felter |
| - | - | - |
| **`standard`** | Provision pr. variant, procent eller fast gebyr | `plan_id`, `commission_type`, `commission_value`, `applies_to_payments` |
| **`rev_share`** | Procentvis omsætningsandel, produktspecifik eller for hele kontoen | `commission_value` (altid procent) og valgfrit `product_id` |

### Standard (pr. variant)

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

Regler for `commission_value`:

* `"percentage"`: heltal 1–100 (`40` = 40 %).
* `"flat_fee"`: dollarbeløb (`10` = \$10).

`applies_to_payments`:

* `"first_payment"`: affiliaten tjener kun på det første køb.
* `"all_payments"`: affiliaten tjener også på hver tilbagevendende betaling.

### Rev-share (procent af omsætningen)

Rev-share-overrides er altid procentbaserede. Angiv ikke `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)
}
```

## Administrer 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)
}
```

## Administrer affiliates

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

## Affiliate-indstillinger på kontoniveau

Tre kontofelter styrer, hvordan Whop præsenterer [affiliateprogrammet](https://docs.whop.com/da/manage-your-business/growth-marketing/affiliate-program.md) for brugerne. Opdater dem via Account-ressourcen.

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

| Felt | Beskrivelse |
| - | - |
| `affiliate_instructions` | Retningslinjer, der vises for affiliates, som promoverer denne konto |
| `affiliate_application_required` | Om brugere skal ansøge og godkendes, før de kan blive affiliates |
| `featured_affiliate_product_id` | Hvilket produkt der skal fremhæves til affiliate-promovering |

## Sporing af indtjening

Hver override indeholder feltet `total_referral_earnings_usd`, som afspejler den samlede indtjening (i amerikanske dollars) for netop den override. Hent overriden igen (eller list overrides på en affiliate) for at få den aktuelle total.

> [!NOTE]
>
> Der findes ingen dedikeret `affiliate.*`-webhook i v1, og det offentlige `payment`-skema eksponerer ikke koblingen til affiliates. Poll `affiliates.overrides.list` efter din udbetalingsplan, og sammenlign de seneste værdier af `total_referral_earnings_usd` med de sidste værdier, du har gemt.

## Svarfelter for overrides

| Felt | Beskrivelse |
| - | - |
| `override_type` | `"standard"` eller `"rev_share"` |
| `commission_type` | `"percentage"` eller `"flat_fee"` |
| `commission_value` | Procent (1–100) eller fast gebyr i dollars |
| `applies_to_payments` | `"first_payment"` eller `"all_payments"` (kun standard, `null` for rev-share) |
| `plan_id` | Variant-ID, der beholder præfikset `plan_` (kun standard) |
| `product_id` | Produkt-ID (kun rev-share, `null` hvis for hele kontoen) |
| `applies_to_products` | `"single_product"` eller `"all_products"` (kun rev-share) |
| `product_direct_link` | Henvisningslink til produktsiden (kun standard) |
| `checkout_direct_link` | Henvisningslink til checkout-siden (kun standard) |
| `total_referral_earnings_usd` | Samlet indtjening for denne override |

## Næste trin

> [card] [Udbetal affiliate-indtjening](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md#transfers)
>
> Overfør opsparede provisioner fra din saldo til affiliate-konti.

> [card] [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
>
> Checkout-konfigurationer tilskriver salg automatisk, når henvisningscookies er sat.

> [card] [Lyt til webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Brug `payment.succeeded` til generel salgstelemetri. Affiliate-attribuering kræver stadig polling.

> [card] [API-reference for Affiliates](https://docs.whop.com/da/api-reference/legacy/affiliates/affiliate.md)
>
> Hele ressourcen. Endpoints, felter og override-skemaer.
