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

# Afiliados

> Crea registros de afiliados, asigna anulaciones de comisión por variante o de reparto de ingresos y haz un seguimiento de las ganancias por referidos.

Los afiliados ganan comisiones por las ventas que refieren. El flujo de la API tiene dos partes: crear un registro de afiliado y, después, añadir anulaciones (overrides) que definen la comisión.

## Cómo funciona la atribución

1. Creas un registro de afiliado para un usuario y luego añades anulaciones. Cada anulación devuelve los campos `product_direct_link` y `checkout_direct_link`. Son URL de referido que comparte el afiliado (incluyen `?a=<username>`).
2. Un comprador usa el enlace. Whop guarda la cookie del afiliado (ventana de atribución de 30 días por defecto).
3. El comprador paga dentro de la ventana. La anulación correspondiente calcula la comisión: `standard` (por variante, porcentaje o tarifa fija) o `rev_share` (porcentaje de los ingresos, para un producto concreto o para toda la cuenta).
4. Whop atribuye la comisión al afiliado y la refleja en el campo `total_referral_earnings_usd` de la anulación.

> [!NOTE]
>
> **Los reembolsos revierten las comisiones.** Si un comprador obtiene un reembolso dentro de la ventana, la ganancia del afiliado en esa venta se recupera automáticamente.

> [!NOTE]
>
> **Los afiliados necesitan una cuenta de Whop para recibir pagos.** Las ganancias se acumulan en el registro. Los pagos van a su saldo de cuenta mediante [transferencias](https://docs.whop.com/es/developer/platforms/collect-payments-for-subaccounts.md#transfers). Si todavía no tienen una cuenta, dalos de alta con la [inscripción de subcuentas](https://docs.whop.com/es/developer/platforms/enroll-subaccounts.md).

## Crear un afiliado

`user_identifier` se resuelve de forma flexible. Pasa un nombre de usuario, un correo electrónico, un ID de usuario o un ID de Discord. Si ya existe un registro de afiliado para el par de cuenta y usuario, Whop devuelve el registro existente (idempotente).

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

## Añadir anulaciones de comisión

Un registro de afiliado no define una comisión por sí solo. Añade **anulaciones** para decidir cuánto se le paga al afiliado.

| Tipo de anulación | Qué hace | Campos obligatorios |
| - | - | - |
| **`standard`** | Comisión por variante, porcentaje o tarifa fija | `plan_id`, `commission_type`, `commission_value`, `applies_to_payments` |
| **`rev_share`** | Reparto porcentual de los ingresos, para un producto concreto o para toda la cuenta | `commission_value` (siempre porcentaje) y `product_id` opcional |

### Estándar (por 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)
```

Reglas de `commission_value`:

* `"percentage"`: número entero de 1 a 100 (`40` = 40 %).
* `"flat_fee"`: importe en dólares (`10` = 10 \$).

`applies_to_payments`:

* `"first_payment"`: el afiliado solo gana con la compra inicial.
* `"all_payments"`: el afiliado también gana con cada pago recurrente.

### Reparto de ingresos (porcentaje de los ingresos)

Las anulaciones de reparto de ingresos siempre se basan en un porcentaje. No pases `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)
}
```

## Gestionar anulaciones

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

## Gestionar afiliados

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

## Configuración de afiliados a nivel de cuenta

Tres campos de la cuenta controlan cómo presenta Whop el [programa de afiliados](https://docs.whop.com/es/manage-your-business/growth-marketing/affiliate-program.md) a los usuarios. Actualízalos a través del recurso 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)
}
```

| Campo | Descripción |
| - | - |
| `affiliate_instructions` | Pautas que se muestran a los afiliados que promocionan esta cuenta |
| `affiliate_application_required` | Si los usuarios deben solicitarlo y recibir aprobación antes de convertirse en afiliados |
| `featured_affiliate_product_id` | Qué producto destacar para la promoción de afiliados |

## Seguimiento de ganancias

Cada anulación incluye un campo `total_referral_earnings_usd` que refleja las ganancias acumuladas (en dólares estadounidenses) de esa anulación concreta. Vuelve a obtener la anulación (o lista las anulaciones de un afiliado) para conseguir el total actual.

> [!NOTE]
>
> No hay ningún webhook `affiliate.*` dedicado en v1, y el esquema público de `payment` no expone la vinculación con afiliados. Consulta periódicamente `affiliates.overrides.list` según tu calendario de pagos y compara los últimos valores de `total_referral_earnings_usd` con los últimos valores que guardaste.

## Campos de respuesta de una anulación

| Campo | Descripción |
| - | - |
| `override_type` | `"standard"` o `"rev_share"` |
| `commission_type` | `"percentage"` o `"flat_fee"` |
| `commission_value` | Porcentaje (1–100) o tarifa fija en dólares |
| `applies_to_payments` | `"first_payment"` o `"all_payments"` (solo standard, `null` para rev-share) |
| `plan_id` | ID de la variante, que conserva el prefijo `plan_` (solo standard) |
| `product_id` | ID del producto (solo rev-share, `null` si es para toda la cuenta) |
| `applies_to_products` | `"single_product"` o `"all_products"` (solo rev-share) |
| `product_direct_link` | Enlace de referido a la página del producto (solo standard) |
| `checkout_direct_link` | Enlace de referido a la página de checkout (solo standard) |
| `total_referral_earnings_usd` | Ganancias acumuladas de esta anulación |

## Próximos pasos

> [card] [Pagar las ganancias de afiliados](https://docs.whop.com/es/developer/platforms/collect-payments-for-subaccounts.md#transfers)
>
> Transfiere las comisiones acumuladas desde tu saldo a las cuentas de los afiliados.

> [card] [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md)
>
> Las configuraciones de checkout atribuyen las ventas automáticamente cuando hay cookies de referido.

> [card] [Escuchar webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Usa `payment.succeeded` para la telemetría general de ventas. La atribución de afiliados sigue requiriendo consultas periódicas.

> [card] [Referencia de la API de afiliados](https://docs.whop.com/es/api-reference/legacy/affiliates/affiliate.md)
>
> Recurso completo. Endpoints, campos y esquemas de anulaciones.


## Related topics

- [Afiliado](https://docs.whop.com/es/api-reference/legacy/affiliates/affiliate.md)
- [API de actividad financiera](https://docs.whop.com/es/api-reference/ledgers/ledger-activity.md)
- [Implementa un negocio a partir de un blueprint](https://docs.whop.com/es/developer/websites/blueprints.md)
