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

# Cobrar pagos para subcuentas

> Cobra pagos para subcuentas con cargos directos y una comisión de aplicación, o con transferencias desde la cuenta de tu plataforma, además de las limitaciones y los fallos.

Hay dos formas de cobrar pagos para subcuentas:

1. **Cargos directos**: crea un checkout para la subcuenta y cobra una comisión de aplicación.
2. **Transferencias**: cobra el pago en la cuenta de tu plataforma y transfiere fondos a las subcuentas más tarde.

## Cargos directos

Crea una configuración de checkout con el ID de una subcuenta para cobrar a los clientes directamente en la subcuenta. La subcuenta es responsable de las comisiones de Whop, los reembolsos y las disputas.

### Cómo funciona

1. Crea una configuración de checkout para tu subcuenta con un `application_fee_amount`
2. Cuando un cliente compra, Whop crea el cargo directamente en la subcuenta
3. Tu plataforma cobra la comisión de aplicación y el importe restante va a la subcuenta
4. La subcuenta gestiona las disputas o reembolsos de la transacción

### Ejemplo

Crea una variante en línea usando la entrada de compatibilidad llamada `plan`.

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

const client = new WhopClient({
	token: "Account API Key",
});

const checkoutConfig = await client.checkoutConfigurations.create({
	account_id: "biz_xxxxxxxxxxxxx", // Subaccount's ID
	variant: {
		initial_price: 10.0,
		billing_type: "one_time",
		application_fee_amount: 1.23,
	},
});

console.log(checkoutConfig.purchase_url);
```

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

client = Whop(
    token="Account API Key",
)

checkout_config = client.checkout_configurations.create(
    account_id="biz_xxxxxxxxxxxxx",  # Subaccount's ID
    variant={
        "initial_price": 10.0,
        "billing_type": "one_time",
        "application_fee_amount": 1.23,
    },
)

print(checkout_config.purchase_url)
```

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

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let checkout_config = client
    .checkout_configurations
    .create(
        &CreateCheckoutConfigurationsRequest {
            account_id: Some("biz_xxxxxxxxxxxxx".to_string()), // Subaccount's ID
            variant: Some(CreateCheckoutConfigurationsRequestVariant {
                initial_price: Some(10.0),
                billing_type: Some(CreateCheckoutConfigurationsRequestVariantBillingType::OneTime),
                application_fee_amount: Some(1.23),
                ..Default::default()
            }),
            ..Default::default()
        },
        None,
    )
    .await?;

println!("{}", checkout_config.purchase_url.unwrap());
```

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

    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("Account API Key"))

checkoutConfig, err := client.CheckoutConfigurations.Create(context.TODO(), &whopsdk.CreateCheckoutConfigurationsRequest{
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxx"), // Subaccount's ID
    Variant: &whopsdk.CreateCheckoutConfigurationsRequestVariant{
        InitialPrice:         whopsdk.Float64(10.0),
        BillingType:          whopsdk.CreateCheckoutConfigurationsRequestVariantBillingTypeOneTime.Ptr(),
        ApplicationFeeAmount: whopsdk.Float64(1.23),
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(*checkoutConfig.PurchaseURL)
```

En este ejemplo:

* `account_id` es el ID de la subcuenta donde Whop creará el cargo
* `variant.initial_price` es el importe total del pago de la variante (10,00 dólares estadounidenses)
* `variant.application_fee_amount` es la comisión que cobra tu plataforma (1,23 dólares estadounidenses)
* La subcuenta recibe 8,77 dólares estadounidenses (10,00 - 1,23)

### Limitaciones

* El `application_fee_amount` debe ser positivo e inferior al importe total del pago
* La comisión de aplicación no puede superar el importe capturado del pago

## Transferencias

Usa transferencias cuando tu plataforma cobra primero el pago o cuando tu backend decide cuánto y cuándo pagar a cada subcuenta.

### Antes de transferir

* **Cuenta de origen**: la cuenta que envía los fondos debe completar la verificación Know Your Customer (KYC) y tener saldo suficiente para la transferencia. Puedes recargar el saldo desde el panel o mediante [Añadir fondos a tu saldo](https://docs.whop.com/es/developer/platforms/add-funds-to-your-balance.md).
* **Cuenta de destino**: el destinatario ya debe tener una cuenta de Whop. Si no la tiene, incorpóralo primero con [Dar de alta subcuentas](https://docs.whop.com/es/developer/platforms/enroll-subaccounts.md).
* **Titularidad de la liquidación**: con las transferencias, tu plataforma es el comerciante registrado (merchant of record) del pago original. Tu plataforma gestiona las comisiones, disputas y reembolsos de ese pago.

### Ejemplo

Cobra el pago en la cuenta de tu plataforma y luego transfiere la parte de la subcuenta:

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

const client = new WhopClient({
	token: "Account API Key",
});

const transfer = await client.transfers.create({
	type: "balance",
	amount: 90.0,
	currency: "usd",
	origin_id: "biz_yyyyyyyyyyyyy", // Platform's account ID
	destination_id: "biz_xxxxxxxxxxxxx", // Subaccount's ID
	metadata: {
		order_id: "order_12345",
	},
});

if (transfer.object === "transfer") {
	console.log(transfer.id);
}
```

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

client = Whop(
    token="Account API Key",
)

transfer = client.transfers.create(
    type="balance",
    amount=90.0,
    currency="usd",
    origin_id="biz_yyyyyyyyyyyyy",  # Platform's account ID
    destination_id="biz_xxxxxxxxxxxxx",  # Subaccount's ID
    metadata={
        "order_id": "order_12345",
    },
)

if transfer.object == "transfer":
    print(transfer.id)
```

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

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let transfer = client
    .transfers
    .create(
        &CreateTransfersRequest {
            amount: 90.0,
            currency: Some("usd".to_string()),
            origin_id: "biz_yyyyyyyyyyyyy".to_string(), // Platform's account ID
            destination_id: Some("biz_xxxxxxxxxxxxx".to_string()), // Subaccount's ID
            metadata: Some(HashMap::from([("order_id".to_string(), json!("order_12345"))])),
            ..Default::default()
        },
        None,
    )
    .await?;

if let CreateTransfersResponse::Transfer { id, .. } = &transfer {
    println!("{id}");
}
```

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

    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("Account API Key"))

transfer, err := client.Transfers.Create(context.TODO(), &whopsdk.CreateTransfersRequest{
    Amount:        90.0,
    Currency:      whopsdk.String("usd"),
    OriginID:      "biz_yyyyyyyyyyyyy",                 // Platform's account ID
    DestinationID: whopsdk.String("biz_xxxxxxxxxxxxx"), // Subaccount's ID
    Metadata:      map[string]any{"order_id": "order_12345"},
})
if err != nil {
    log.Fatal(err)
}

if transfer.Object == "transfer" {
    fmt.Println(transfer.Transfer.ID)
}
```

En este ejemplo:

* `origin_id` es el ID de la cuenta de tu plataforma (de donde Whop descuenta los fondos)
* `destination_id` es el ID de la subcuenta (donde Whop abona los fondos)
* `amount` es el importe que se transferirá
* `metadata` almacena datos personalizados para tu referencia

### Gestionar los fallos de transferencia

Las transferencias fallan si la cuenta de origen no está verificada, si el saldo de origen es insuficiente o si la cuenta de destino aún no puede recibir fondos. Corrige la causa subyacente antes de reintentar. No reintentes transferencias fallidas sin revisar la causa.

### Usos habituales

* Pagos salientes programados a creadores
* Pagos salientes a afiliados
* Repartos de marketplace después de que se liquide un pedido

## Elegir un flujo de pago

| | Cargos directos | Transferencias |
| - | - | - |
| **Comisiones** | La subcuenta paga las comisiones de Whop | La plataforma paga las comisiones de Whop |
| **Disputas** | La subcuenta gestiona las disputas | La plataforma gestiona las disputas |
| **Reembolsos** | La subcuenta gestiona los reembolsos | La plataforma gestiona los reembolsos |

Usa transferencias cuando tu backend controla el momento y el importe de los pagos salientes. Usa cargos directos cuando la subcuenta deba asumir las comisiones, disputas y reembolsos de la compra original.

## Referencia de la API

> [card] [Create Checkout Configuration](https://docs.whop.com/es/api-reference/legacy/checkout-configurations/create-checkout-configuration.md)
>
> Crea configuraciones de checkout con comisiones de aplicación

> [card] [Create Transfer](https://docs.whop.com/es/api-reference/transfers/create-transfer.md)
>
> Transfiere fondos entre cuentas

## Recursos relacionados

> [card] [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md)
>
> Descubre los enlaces de checkout y el Checkout element

> [card] [Dar de alta subcuentas](https://docs.whop.com/es/developer/platforms/enroll-subaccounts.md)
>
> Crea cuentas de destinatarios y completa la incorporación antes de pagarles


## Related topics

- [Añadir fondos a tu saldo](https://docs.whop.com/es/developer/platforms/add-funds-to-your-balance.md)
- [Dar de alta subcuentas](https://docs.whop.com/es/developer/platforms/enroll-subaccounts.md)
- [Pagos salientes manuales a subcuentas](https://docs.whop.com/es/developer/platforms/manual-payouts.md)
