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

# Guardar métodos de pago

> Guarda la tarjeta de un cliente en modo de configuración con los payment elements o un checkout alojado, o durante el checkout, y cobra después el método guardado fuera de sesión.

Usa métodos de pago guardados para cobrar automáticamente a los clientes por suscripciones, renovaciones o facturación basada en el uso. El cliente guarda su tarjeta una vez mediante un flujo alojado o incrustado de Whop, y puedes cobrarle en cualquier momento después.

> [!TIP]
>
> Combina esta guía con los [webhooks](https://docs.whop.com/es/developer/guides/webhooks.md): escucha `setup_intent.succeeded` para confirmar el guardado y luego `payment.succeeded` / `payment.failed` para hacer seguimiento de los cobros futuros.

## Elige tu flujo de guardado

Hay dos caminos, según si el usuario también está pagando en este momento.

| | Modo de configuración (solo recopilar) | Guardar durante el checkout |
| - | - | - |
| **Cobra al usuario ahora** | No | Sí |
| **Caso de uso** | Registro en una prueba gratuita, tarjeta registrada antes de la facturación basada en el uso | Suscripción que se renueva tras el primer checkout pagado |
| **Cómo** | Monta los [payment elements](https://docs.whop.com/es/elements/latest/payments/overview) en `mode: "setup"` y [crea un setup intent](https://docs.whop.com/es/api-reference/setup-intents/create-setup-intent.md) con el token de confirmación, o abre una [configuración de checkout](https://docs.whop.com/es/api-reference/checkout-configurations/create-a-checkout-configuration.md) en modo de configuración como checkout alojado o en el [Checkout element](https://docs.whop.com/es/elements/latest/checkout/overview) | Monta los payment elements con `setupFutureUsage: "off_session"` y crea el pago con el token de confirmación |
| **Webhook que escuchar** | `setup_intent.succeeded` | `payment.succeeded` (su `payment_method_id` es el método guardado) |

El resto de esta página cubre el modo de configuración de principio a fin y luego muestra cómo cobrar un método guardado más adelante.

## Guardar un método de pago con los payment elements

Crea el formulario de guardado con los [payment elements](https://docs.whop.com/es/elements/latest/payments/overview) en `mode: "setup"`. El element ofrece solo métodos que se pueden guardar, muestra al comprador el consentimiento de uso futuro que requiere el guardado y te entrega un token de confirmación. Conviertes ese token en un setup intent desde tu servidor, y el `client_secret` del setup intent completa cualquier paso que el comprador tenga pendiente.

**1. Monta el formulario en modo de configuración**

Pasa `mode="setup"` y la moneda con la que se usará el método guardado. No hay importe, así que los límites de importe no se aplican. Establece `returnUrl` en una página que alojes sobre `https`. Las inscripciones bancarias y algunos flujos de 3D Secure devuelven al comprador allí.

```tsx React theme={null}
import { useState } from "react";
import {
  WhopElements,
  Payments,
  EmailElement,
  PaymentElement,
  BrandingElement,
  usePayments,
  useWhop,
} from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function SavePaymentMethodPage() {
  return (
    <WhopElements elements={loadWhop()}>
      <Payments
        accountId="biz_XXXXXXXX"
        mode="setup"
        currency="usd"
        returnUrl="https://yoursite.com/billing/saved"
      >
        <SaveForm />
      </Payments>
    </WhopElements>
  );
}

function SaveForm() {
  const payments = usePayments();
  const whop = useWhop();
  const [ready, setReady] = useState(false);
  const [error, setError] = useState<string | null>(null);

  async function save() {
    if (!payments || !whop) return;
    setError(null);

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      setError("The payment method couldn't be saved. Try a different one.");
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    setError(result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.");
  }

  return (
    <>
      <EmailElement />
      <PaymentElement onChange={(event) => setReady(event.complete)} />
      <BrandingElement />
      <button disabled={!ready} onClick={save}>
        Save payment method
      </button>
      {error && <p role="alert">{error}</p>}
    </>
  );
}
```

```html JavaScript theme={null}
<script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>

<div id="email"></div>
<div id="payment"></div>
<div id="branding"></div>
<button id="save" disabled>Save payment method</button>
<p id="error" role="alert"></p>

<script type="module">
  const whop = window.WhopElements();
  const payments = whop.payments.create({
    accountId: "biz_XXXXXXXX",
    mode: "setup",
    currency: "usd",
    returnUrl: "https://yoursite.com/billing/saved",
  });

  const saveButton = document.querySelector("#save");
  const errorLine = document.querySelector("#error");

  payments.create("email").mount("#email");
  payments
    .create("payment", { onChange: (event) => (saveButton.disabled = !event.complete) })
    .mount("#payment");
  payments.create("branding").mount("#branding");

  saveButton.addEventListener("click", async () => {
    errorLine.textContent = "";

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      errorLine.textContent = "The payment method couldn't be saved. Try a different one.";
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    errorLine.textContent = result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.";
  });
</script>
```

El token incluye el consentimiento que mostró el element. El setup intent rechaza un token recopilado desde un formulario en modo de pago, así que monta en `mode="setup"` cuando el comprador no esté pagando.

**2. Crea el setup intent en tu servidor**

[Crea un setup intent](https://docs.whop.com/es/api-reference/setup-intents/create-setup-intent.md) con el token de confirmación. Whop identifica al comprador a partir del correo electrónico del token y responde `201 Created` con el setup intent. Este incluye el `status`, un `client_secret` para cualquier paso que el comprador tenga pendiente y, una vez en `succeeded`, el método guardado como `payment_method_id`. Adjunta `metadata` para vincular el método guardado a un cliente de tu sistema. Se devuelve en el webhook. Envía una [`Idempotency-Key`](https://docs.whop.com/es/developer/api/idempotency) para que una solicitud reintentada nunca guarde el método dos veces.

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

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

export async function POST(request: Request) {
  const { confirmationToken } = await request.json();

  const setupIntent = await client.setupIntents.create({
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmationToken,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  });

  return Response.json({
    id: setupIntent.id,
    status: setupIntent.status,
    client_secret: setupIntent.client_secret,
  });
}
```

```python Python theme={null}
import os
from flask import Flask, jsonify, request
from whop_sdk import Whop

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

@app.post("/api/save-payment-method")
def save_payment_method():
    setup_intent = client.setup_intents.create(
        request={
            "account_id": "biz_XXXXXXXX",
            "confirmation_token": request.get_json()["confirmationToken"],
            "currency": "usd",
            "return_url": "https://yoursite.com/billing/saved",
            "metadata": {"customer_id": "my_internal_user_id"},
        },
    )
    return jsonify(id=setup_intent.id, status=setup_intent.status, client_secret=setup_intent.client_secret)
```

```ruby Ruby theme={null}
require "whop_sdk"

client = Whop_sdk::Client.new(token: ENV.fetch("WHOP_API_KEY"))

post "/api/save-payment-method" do
  confirmation_token = JSON.parse(request.body.read)["confirmationToken"]

  setup_intent = client.setup_intents.create(
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmation_token,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  )

  { id: setup_intent.id, status: setup_intent.status, client_secret: setup_intent.client_secret }.to_json
end
```

**3. Completa cualquier paso pendiente**

Un setup intent que vuelve como `succeeded` tiene el método registrado. `requires_action` significa que el comprador aún tiene un paso pendiente, como 3D Secure o una inscripción bancaria. Pasa el `client_secret` a `handleNextAction`, la misma llamada que usa el flujo de pago. Ejecuta un paso en línea en un diálogo o envía al comprador a tu `returnUrl`. Ramifica según el `status` que devuelve: `succeeded` guardó el método, `processing` aún se está decidiendo y cualquier otro valor requiere otro intento. Un diálogo cerrado deja la configuración en `requires_action` sin error, y `lastPaymentError` incluye el motivo cuando el intento falla. `processing` significa que el procesador aún está decidiendo, así que muestra un estado pendiente y deja que el webhook siguiente confirme el guardado. `canceled` significa que el comprador abandonó el paso o que el proveedor rechazó el método: `last_setup_error` incluye el motivo del proveedor y permanece en `null` cuando el comprador se fue. Para leer el estado desde tu servidor, [obtén el setup intent](https://docs.whop.com/es/api-reference/setup-intents/retrieve-setup-intent.md) y ramifica según el mismo `status`, o consulta periódicamente el endpoint más ligero [Retrieve setup status](https://docs.whop.com/es/api-reference/setup-intents/retrieve-setup-status.md) mientras haya un paso pendiente.

**4. Gestiona la finalización**

Escucha el webhook `setup_intent.succeeded` para obtener el ID del método de pago y recuperar tu `metadata`. Es la única señal que sobrevive a una pestaña cerrada, y el mismo handler sirve para el flujo alojado que se describe más abajo. El setup intent también incluye `payment_instrument` para mostrarlo: un nombre, el conjunto de iconos estándar y, en el caso de una tarjeta, su marca, los últimos cuatro dígitos y la fecha de caducidad. Puedes mostrar el método guardado sin otra solicitud. Los webhooks fijados a una versión anterior a la versión de API 2026-09-22-1 incluyen el método guardado como `payment_method.id`.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

  return new Response("OK", { status: 200 });
}

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Saved method:", setupIntent.payment_instrument?.display_name);
  console.log("Metadata:", setupIntent.metadata);
}
```

El método de pago ya está guardado y autorizado para este miembro. Cóbralo con los pasos de [Cobrar un método de pago guardado](#charge-a-saved-payment-method).

## Guardar un método de pago con un checkout alojado

**1. Crea una configuración de checkout en modo de configuración**

[Crea una configuración de checkout](https://docs.whop.com/es/api-reference/checkout-configurations/create-a-checkout-configuration.md) sin variante para recopilar los datos de pago sin cobrar. Añade metadatos para poder vincular el miembro y el método de pago a un cliente de tu sistema.

```typescript TypeScript theme={null}
const checkoutConfiguration = await whopsdk.checkoutConfigurations.create({
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
});
```

```python Python theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
    account_id="biz_XXXXXX",
    mode="setup",
    redirect_url="https://mywebsite.com/return_location",
    metadata={"customer_id": "my_internal_user_id"},
)
```

```ruby Ruby theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
)
```

```rust Rust theme={null}
let checkout_configuration = client
    .checkout_configurations
    .create(
        &CreateCheckoutConfigurationsRequest {
            account_id: Some("biz_XXXXXX".to_string()),
            mode: Some(CreateCheckoutConfigurationsRequestMode::Setup),
            redirect_url: Some("https://mywebsite.com/return_location".to_string()),
            metadata: Some(HashMap::from([(
                "customer_id".to_string(),
                json!("my_internal_user_id"),
            )])),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
checkoutConfiguration, err := client.CheckoutConfigurations.Create(context.TODO(), &whopsdk.CreateCheckoutConfigurationsRequest{
    AccountID:   whopsdk.String("biz_XXXXXX"),
    Mode:        whopsdk.CreateCheckoutConfigurationsRequestModeSetup.Ptr(),
    RedirectURL: whopsdk.String("https://mywebsite.com/return_location"),
    Metadata:    map[string]any{"customer_id": "my_internal_user_id"},
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(checkoutConfiguration.ID)
```

**2. Dirige al usuario al checkout**

Monta el Checkout element o redirige al usuario para que guarde su método de pago.

> [tab] Incrustado
>
> ```tsx theme={null}
> import { WhopElements, Checkout, CheckoutElement } from "@whop/elements-react";
> import { loadWhop } from "@whop/elements";
>
> export default function SavePayment({ configurationId }: { configurationId: string }) {
>   return (
>     <WhopElements elements={loadWhop()}>
>       <Checkout
>         checkoutConfiguration={configurationId}
>         returnUrl="https://yoursite.com/setup/complete"
>       >
>         <CheckoutElement />
>       </Checkout>
>     </WhopElements>
>   );
> }
> ```
>
> Una configuración en modo de configuración monta el mismo element como un guardado
> de método de pago: no se cobra nada y el checkout finalizado redirige a
> `returnUrl` con `setup_intent_id` en la cadena de consulta. Confirma el guardado
> desde el webhook `setup_intent.succeeded` y no desde la redirección.

> [tab] Redirección
>
> ```typescript theme={null}
> window.location.href = checkoutConfiguration.purchase_url;
> ```

**3. Gestiona la finalización**

Escucha el webhook `setup_intent.succeeded` para obtener el ID del método de pago. El setup intent incluye `checkout_configuration_id` y la `metadata` de la configuración, que puedes usar para vincular el miembro y el método de pago a un cliente de tu sistema.

> [!NOTE]
>
> Confirma el guardado desde el webhook y no a partir de la llegada del comprador a tu `redirect_url`. Es la única señal que sobrevive a una pestaña cerrada.

> [!TIP]
>
> El ejemplo usa `waitUntil` de `@vercel/functions` para ejecutar el handler después de responder `200`. En otros runtimes (Bun, Cloudflare Workers, Fastify, Hono), sustitúyelo por la primitiva equivalente de tareas en segundo plano de tu framework o por una cola de trabajos. Consulta la [guía de webhooks](https://docs.whop.com/es/developer/guides/webhooks.md) para ver handlers equivalentes en Python y Ruby.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

  return new Response("OK", { status: 200 });
}

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Member ID:", setupIntent.member_id);
  console.log("Checkout configuration ID:", setupIntent.checkout_configuration_id);
  console.log("Metadata:", setupIntent.metadata);
}
```

El método de pago ya está guardado y autorizado para este miembro.

## Cobrar un método de pago guardado

**1. Obtén el método de pago**

[Lista los métodos de pago guardados](https://docs.whop.com/es/api-reference/legacy/payment-methods/list-payment-methods.md) de un miembro o usa el `payment_method_id` del setup intent del paso anterior.

```typescript TypeScript theme={null}
const payment_methods = await whopsdk.paymentMethods.list({
  member_id: "mber_XXXXXXXX",
});

const payment_method = payment_methods.data[0];
```

```python Python theme={null}
payment_methods = whopsdk.payment_methods.list(member_id="mber_XXXXXXXX")
payment_method = payment_methods.items[0]
```

```ruby Ruby theme={null}
# list returns an Enumerable that pages for you; there is no `.data` on it
payment_method = whopsdk.payment_methods.list(member_id: "mber_XXXXXXXX").first
```

```rust Rust theme={null}
let payment_methods = client
    .payment_methods
    .list(
        &PaymentMethodsListQueryRequest {
            member_id: Some("mber_XXXXXXXX".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

let payment_method = &payment_methods.data[0];
```

```go Go theme={null}
page, err := client.PaymentMethods.List(context.TODO(), &whopsdk.ListPaymentMethodsRequest{
    MemberID: whopsdk.String("mber_XXXXXXXX"),
})
if err != nil {
    log.Fatal(err)
}

paymentMethod := page.Results[0]
fmt.Println(paymentMethod)
```

**2. Crea un pago fuera de sesión**

Cobra el método de pago sin interacción del cliente. El [endpoint de creación de pagos](https://docs.whop.com/es/api-reference/payments/create-payment.md) devuelve un objeto de pago inmediatamente y procesa el cobro de forma asíncrona.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
});

console.log("Payment:", payment.id);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "member_id": "mber_XXXXXXXX",
        "payment_method_id": "payt_XXXXXXXXX",
    },
)

print("Payment:", payment.id)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
)

puts "Payment: #{payment.id}"
```

```rust Rust theme={null}
let payment = client
    .payments
    .create(
        &CreatePaymentsRequestBody::CreatePaymentsRequestBodyOne(
            CreatePaymentsRequestBodyOne::builder()
                .account_id("biz_XXXXXXXX")
                .variant_id("plan_XXXXXXXX")
                .member_id("mber_XXXXXXXX")
                .payment_method_id("payt_XXXXXXXXX")
                .build()
                .unwrap(),
        ),
        None,
    )
    .await?;

println!("Payment: {}", payment.payment_fields.id);
```

```go Go theme={null}
payment, err := client.Payments.Create(context.TODO(), &whopsdk.CreatePaymentsRequest{
    CreatePaymentsRequestOne: &whopsdk.CreatePaymentsRequestOne{
        AccountID:       "biz_XXXXXXXX",
        VariantID:       "plan_XXXXXXXX",
        MemberID:        "mber_XXXXXXXX",
        PaymentMethodID: whopsdk.String("payt_XXXXXXXXX"),
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println("Payment:", payment.ID)
```

> [!TIP]
>
> También puedes enviar `line_items` para combinar variantes existentes con precios creados en línea. Cada elemento acepta exactamente uno de `variant_id` o `variant`:
>
> ```json theme={null}
> {
>   "account_id": "biz_XXXXXXXX",
>   "member_id": "mber_XXXXXXXX",
>   "payment_method_id": "payt_XXXXXXXX",
>   "line_items": [
>     { "variant_id": "plan_XXXXXXXX", "quantity": 1 },
>     {
>       "variant": {
>         "product_id": "prod_XXXXXXXX",
>         "currency": "usd",
>         "billing_type": "one_time",
>         "initial_price": 7,
>         "allow_multiple_quantity": true
>       },
>       "quantity": 3
>     }
>   ]
> }
> ```
>
> Crear una variante requiere `plan:create` además de `payment:charge`. Reutilizar una variante coincidente por `product_id` solo necesita `payment:charge`. Una definición de `product` en línea también requiere `access_pass:create` para crear el producto, o `access_pass:update` para actualizar uno existente. Las variantes deben pertenecer a la cuenta del pago y cumplir las reglas de compatibilidad del carrito. La `variant` en línea usa el mismo comportamiento de buscar o crear que una `variant` de nivel superior. Pasa `force_create_new_plan: true` para forzar una variante nueva. Los campos anidados de variante y producto siguen `Api-Version-Date`, y las propiedades desconocidas se rechazan. Usa una `Idempotency-Key` para repetir la solicitud sin crear otro pago.
>
> Para aplicar un descuento, pasa el ID de uno de tus [códigos promocionales](https://docs.whop.com/es/manage-your-business/growth-marketing/promo-codes.md) como `promo_code_id` y Whop calcula el precio con descuento por ti. El código promocional debe estar activo y ser válido para la variante, y la variante debe pertenecer a un producto.

**3. Gestiona los eventos de pago**

Escucha los webhooks de pago para hacer seguimiento de los éxitos o fallos.

```typescript theme={null}
if (webhookData.type === "payment.succeeded") {
  await fulfillOrder(webhookData.data);
}

if (webhookData.type === "payment.failed") {
  await notifyCustomer(webhookData.data.customer_email, webhookData.data.failure_message);
}
```

## Guardar durante el checkout

Para guardar un método de pago mientras cobras al comprador, crea el checkout con los [payment elements](https://docs.whop.com/es/elements/latest/payments/overview) y pasa `setupFutureUsage: "off_session"` en el handle de `Payments`. Los elements muestran al comprador el consentimiento de guardado y lo registran en el token de confirmación, y el pago almacena el método solo cuando ese consentimiento está acreditado.

La propiedad de Elements para seleccionar una variante sigue llamándose `plan` por compatibilidad.

**1. Monta el formulario con consentimiento de guardado**

```tsx theme={null}
<WhopElements elements={loadWhop()}>
  <Payments
    accountId="biz_XXXXXXXX"
    plan="plan_XXXXXXXX"
    setupFutureUsage="off_session"
    returnUrl="https://yoursite.com/checkout/complete"
  >
    <EmailElement />
    <PaymentElement onChange={(event) => setReady(event.complete)} />
    <BrandingElement />
  </Payments>
</WhopElements>
```

[Crear un checkout con payment elements](https://docs.whop.com/es/developer/guides/payment-elements.md) explica el botón de pago, `createConfirmationToken` y `handleNextAction`.

**2. Crea el pago con el token de confirmación**

La respuesta de creación es el pago tal como se abrió, no su resultado. El `payment_method_id` del método guardado llega en el webhook `payment.succeeded` una vez que se completa el cobro.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmationToken,
  return_url: "https://yoursite.com/checkout/complete",
});

console.log("Payment:", payment.id, payment.status);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "confirmation_token": confirmation_token,
        "return_url": "https://yoursite.com/checkout/complete",
    },
)

print("Payment:", payment.id, payment.status)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmation_token,
  return_url: "https://yoursite.com/checkout/complete",
)

puts "Payment: #{payment.id} #{payment.status}"
```

**3. Cóbralo más tarde**

`payment_method_id` es el método `payt_` que debes usar en [Cobrar un método de pago guardado](#charge-a-saved-payment-method). Permanece en `null` cuando no se guardó nada. El webhook `payment.succeeded` incluye el mismo campo, y es la vía que sobrevive a una pestaña cerrada.

## Próximos pasos

> [card] [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md)
>
> Checkouts únicos y de suscripción para combinar con tu flujo de guardado.

> [card] [Checkout element](https://docs.whop.com/es/elements/latest/checkout/overview)
>
> Monta el checkout de Whop en tu propio sitio con Whop Elements.

> [card] [Escuchar webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Haz seguimiento de `setup_intent.succeeded`, `payment.succeeded` y `payment.failed`.

> [card] [Portal de facturación](https://docs.whop.com/es/payments-and-billing/manage-billing/billing-portal.md)
>
> Permite que los clientes gestionen y eliminen sus métodos de pago guardados.


## Related topics

- [Aceptar pagos](https://docs.whop.com/es/developer/guides/accept-payments.md)
- [Descripción general de pagos](https://docs.whop.com/es/developer/payments/overview.md)
- [Crea un checkout con Payment Elements](https://docs.whop.com/es/developer/guides/payment-elements.md)
