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

# Crea un checkout con Payment Elements

> Diseña tu propio checkout en torno a los payment elements: obtén un token de confirmación en el navegador, cóbralo desde tu servidor y completa el pedido desde un webhook

Diseña tu propio checkout en torno a los payment elements de Whop. Los elementos recopilan el método de pago en campos aislados según PCI y te entregan un token de confirmación. Tu servidor pasa ese token a la Payments API para cobrar, o a la Setup Intents API para guardar el método. Después, el navegador completa cualquier paso que el comprador tenga pendiente.

Los archivos de **Código** incluyen comentarios `Step X.Y` que remiten a los pasos siguientes. Elige una implementación de servidor y una implementación de cliente. La lista incluye los archivos de todas las opciones.

## Crea el formulario de pago

### 1.1 Instala los paquetes (React)

Instala los paquetes de Whop Elements para React.

```bash npm theme={null}
npm install @whop/elements-react @whop/elements
```

```bash pnpm theme={null}
pnpm add @whop/elements-react @whop/elements
```

### 1.1 Añade la etiqueta script (JavaScript)

Carga el script de Whop Elements en la página que aloja tu checkout.

### 1.2 Monta los elementos

Crea un handle `Payments` para la variante mediante la propiedad `plan` existente y monta tres elementos debajo. `EmailElement` recopila el correo electrónico del comprador y ofrece a un comprador de Whop reconocido un inicio de sesión que desbloquea sus métodos de pago guardados. `PaymentElement` muestra los métodos disponibles para la variante y el país del comprador, y recopila los campos de cada método en frames alojados, de modo que los números de tarjeta nunca llegan a tu página. `BrandingElement` muestra el aviso de Whop como merchant of record, que todo formulario de pago debe incluir.

El handle resuelve por sí solo la moneda, el importe y los métodos de pago de la variante. Establece `returnUrl` en una página que alojes con `https`. Las redirecciones bancarias, las solicitudes de financiación y algunos flujos de 3D Secure devuelven allí al comprador. Añade tus propios parámetros de consulta, como el ID del pedido. Se conservan durante todo el recorrido.

Para guardar un método de pago sin cobrarlo, monta los mismos elementos con `mode: "setup"` y una `currency` en lugar de un `plan`. La guía [Guardar métodos de pago](https://docs.whop.com/es/developer/guides/save-payment-methods.md) explica ese formulario.

### 1.3 Habilita el botón de pago

`PaymentElement` informa de `complete: true` mediante `onChange` una vez que el comprador ha elegido un método y ha rellenado lo que necesita. Habilita tu botón de pago a partir de ello. El botón es tuyo: su texto, su posición y lo que ocurre al pulsarlo.

### 1.4 Crea el token de confirmación

Al pulsar, llama a `createConfirmationToken`. Convierte lo que han recopilado los elementos en un token `ctok_` de un solo uso que representa al método de pago. El token incluye el correo electrónico y los datos de facturación que reunieron los elementos. Si se elige un monedero, Apple Pay o Google Pay se abren durante esta llamada, y la llamada se rechaza mientras no haya un `BrandingElement` en la página.

Envía el token a tu servidor junto con tu propia referencia de pedido. El token es lo único del método de pago que sale del navegador.

## Cobra desde tu servidor

### 2.1 Instala el SDK de Whop (Next.js)

Instala el SDK de Whop y crea un cliente con la clave de API de tu cuenta. La clave permanece en el servidor. El navegador nunca la ve.

```bash npm theme={null}
npm install @whop/sdk @vercel/functions
```

```bash pnpm theme={null}
pnpm add @whop/sdk @vercel/functions
```

### 2.1 Instala el SDK de Whop (Express)

Instala el SDK de Whop y crea un cliente con la clave de API de tu cuenta. La clave permanece en el servidor. El navegador nunca la ve.

```bash npm theme={null}
npm install @whop/sdk express
```

```bash pnpm theme={null}
pnpm add @whop/sdk express
```

### 2.1 Instala el SDK de Whop (Python)

Instala el SDK de Whop y crea un cliente con la clave de API de tu cuenta. La clave permanece en el servidor. El navegador nunca la ve.

```bash pip theme={null}
pip install whop-sdk fastapi
```

```bash poetry theme={null}
poetry add whop-sdk fastapi
```

### 2.2 Crea el pago a partir del token de confirmación

Pasa el token a la Payments API. Whop identifica al comprador a partir del correo electrónico del token, cobra la variante y devuelve el pago con un `client_secret`. Devuelve `id`, `status` y `client_secret` al navegador. El `client_secret` solo desbloquea este pago concreto, así que es seguro exponerlo.

Establece `return_url` en la misma página a la que vuelven los elementos. Pon tu propio ID de pedido en `metadata` para que el pago y sus webhooks lo incluyan. En un formulario en modo setup, pasa el token a la [Setup Intents API](https://docs.whop.com/es/api-reference/setup-intents/create-setup-intent.md) en su lugar. Devuelve un setup intent con la misma estructura de `client_secret`.

* `variant_id` es la variante que está comprando el comprador. Pasa una `variant` en línea en su lugar para cobrar un importe que todavía no es una variante guardada
* `confirmation_token` representa al método de pago que recopilaron los elementos
* `metadata` vincula el pago con tu propio pedido

### 2.3 Gestiona el pedido desde el webhook

Whop envía `payment.succeeded` a tu endpoint de webhook una vez que el cargo se realiza correctamente, tanto si el comprador pagó en línea como si volvió de un paso fuera del sitio. Verifica la firma con el helper del SDK y, a continuación, gestiona el pedido: márcalo como pagado, concede el acceso y envía el correo electrónico.

La gestión del pedido debe hacerse aquí y en ningún otro sitio. El comprador puede cerrar el navegador antes de que cargue tu página de retorno, una redirección puede fallar y cualquiera puede escribir un parámetro de consulta a mano. Sigue la [guía de Webhooks](https://docs.whop.com/es/developer/guides/webhooks.md) para crear el webhook y guardar su secreto `ws_` como `WHOP_WEBHOOK_SECRET`.

## Completa el pago

### 3.1 Gestiona la siguiente acción

Un pago que vuelve como `paid` está completo. Cualquier otro valor significa que el comprador todavía tiene un paso pendiente, como 3D Secure o una redirección bancaria, o que el cargo sigue pendiente. Pasa el `client_secret` a `handleNextAction`. Ejecuta un paso en línea en un diálogo y se resuelve con `redirected: false`, o envía al comprador a tu `returnUrl` y se resuelve con `redirected: true`.

Ramifica según el `status` que devuelve. `succeeded` significa que el comprador ha pagado, `processing` significa que el cargo sigue pendiente, y cualquier otro valor requiere otro intento. `lastPaymentError` incluye el motivo cuando lo hay. Un diálogo cerrado deja el pago en `requires_action` sin error, así que la ausencia de error nunca significa éxito.

### 3.2 Lee el resultado de la URL

Un comprador que salió a un paso fuera del sitio llega a `returnUrl` **pase lo que pase** allí. Whop añade tres parámetros de consulta. `payment` es el ID `pay_`. `status` es `succeeded` cuando el comprador ha pagado, `failed` o `canceled` cuando no, y un estado pendiente como `processing` mientras el cargo aún no está decidido. `client_secret` permite a la página consultar periódicamente el estado del pago si quiere esperar a una decisión.

Tus propios parámetros, como `order`, se mantienen en la URL. Los rechazos de tarjeta nunca llegan a esta página, porque `handleNextAction` los notifica en línea. La página de retorno es el único lugar donde tu sitio ve un pago fuera del sitio fallido.

### 3.3 Muestra la vista adecuada

Ramifica según `status`. `succeeded` muestra la página de agradecimiento. `failed` y `canceled` muestran un mensaje indicando que no se ha cobrado al comprador y un enlace para volver al checkout. Cualquier otro valor significa que el cargo sigue pendiente. Indica al comprador que le confirmarás por correo electrónico. Las rutas en línea del formulario envían al comprador a la misma página con los mismos parámetros, así que una sola página gestiona todos los desenlaces.

Trata la página como una visualización del resultado, no como prueba de pago. Cualquiera puede escribir `status=succeeded` en una URL. El acceso, las descargas y la gestión del pedido dependen del webhook `payment.succeeded` en tu servidor.

## Código

### Cliente: React — `PaymentForm.tsx`

```tsx PaymentForm.tsx theme={null}
// Step 1.1: Install the packages
import { useState } from "react";
import {
	BrandingElement,
	EmailElement,
	PaymentElement,
	Payments,
	WhopElements,
	usePayments,
	useWhop,
} from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function CheckoutPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			{/* Step 1.2: Mount the elements */}
			<Payments
				accountId="biz_xxxxxxxxxxxxx"
				plan="plan_xxxxxxxxxxxxx"
				returnUrl={`https://yoursite.com/checkout/return?order=${orderId}`}
			>
				<PaymentForm orderId={orderId} />
			</Payments>
		</WhopElements>
	);
}

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

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

		// Step 1.4: Create the confirmation token
		// A single-use ctok_ token that stands in for the payment method. Card data never touches your page.
		const { confirmationToken } = await payments.createConfirmationToken({});

		const response = await fetch("/api/pay", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({ confirmationToken, orderId }),
		});
		const payment = await response.json();

		// Step 3.1: Handle the next action
		if (payment.status === "paid") {
			window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
			return;
		}

		// Anything but paid means the buyer still has a step, or the charge is still being decided.
		const result = await whop.payments.handleNextAction({
			clientSecret: payment.client_secret,
		});
		// The buyer left for an off-site step; they come back on the return page.
		if (result.redirected) return;

		if (result.status === "succeeded") {
			window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
			return;
		}
		if (result.status === "processing") {
			window.location.assign(`/checkout/return?order=${orderId}&status=processing&payment=${payment.id}`);
			return;
		}
		// A dismissed dialog leaves the payment at requires_action with no error, so a missing error never means success.
		setError(result.lastPaymentError?.message ?? "The payment step wasn't completed. Try again.");
	}

	return (
		<>
			{/* Step 1.2: Mount the elements */}
			<EmailElement />
			{/* Step 1.3: Enable the pay button */}
			<PaymentElement onChange={(event) => setReady(event.complete)} />
			{/* Step 1.2: Mount the elements */}
			<BrandingElement />
			{/* Step 1.3: Enable the pay button */}
			<button disabled={!ready} onClick={pay}>
				Pay
			</button>
			{error && <p role="alert">{error}</p>}
		</>
	);
}
```

### Cliente: React — `CheckoutReturn.tsx`

```tsx CheckoutReturn.tsx theme={null}
export function CheckoutReturn() {
	// Step 3.2: Read the outcome from the URL
	// Whop appends `payment`, `status`, and `client_secret` to your returnUrl. Your own parameters (here `order`) survive.
	const params = new URLSearchParams(window.location.search);
	const paymentId = params.get("payment");
	const status = params.get("status");
	const orderId = params.get("order");

	// Step 3.3: Show the right face
	if (status === "succeeded") {
		return (
			<section>
				<h1>Thanks for your order</h1>
				<p>Payment {paymentId} is complete. A receipt is on its way to your email.</p>
			</section>
		);
	}

	if (status === "failed" || status === "canceled") {
		return (
			<section>
				<h1>Your payment did not go through</h1>
				<p>No money was taken. You can try again with another payment method.</p>
				<a href={`/checkout?order=${orderId}`}>Back to checkout</a>
			</section>
		);
	}

	return (
		<section>
			<h1>Confirming your payment</h1>
			<p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
		</section>
	);
}
```

### Cliente: JavaScript — `checkout.html`

```html checkout.html theme={null}
<!DOCTYPE html>
<html>
  <head>
    <!-- Step 1.1: Add the script tag -->
    <script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
  </head>
  <body>
    <div id="email"></div>
    <div id="payment"></div>
    <div id="branding"></div>
    <button id="pay" disabled>Pay</button>
    <p id="error" role="alert"></p>

    <script type="module">
      const orderId = new URLSearchParams(window.location.search).get("order");

      // Step 1.2: Mount the elements
      const whop = window.WhopElements();
      const payments = whop.payments.create({
        accountId: "biz_xxxxxxxxxxxxx",
        plan: "plan_xxxxxxxxxxxxx",
        returnUrl: `https://yoursite.com/checkout/return?order=${orderId}`,
      });

      payments.create("email").mount("#email");
      const payButton = document.querySelector("#pay");
      const errorLine = document.querySelector("#error");

      // Step 1.3: Enable the pay button
      payments
        .create("payment", { onChange: (event) => (payButton.disabled = !event.complete) })
        .mount("#payment");
      // Step 1.2: Mount the elements
      payments.create("branding").mount("#branding");

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

        // Step 1.4: Create the confirmation token
        // A single-use ctok_ token that stands in for the payment method. Card data never touches your page.
        const { confirmationToken } = await payments.createConfirmationToken({});

        const response = await fetch("/api/pay", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ confirmationToken, orderId }),
        });
        const payment = await response.json();

        // Step 3.1: Handle the next action
        if (payment.status === "paid") {
          window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
          return;
        }

        // Anything but paid means the buyer still has a step, or the charge is still being decided.
        const result = await whop.payments.handleNextAction({
          clientSecret: payment.client_secret,
        });
        // The buyer left for an off-site step; they come back on the return page.
        if (result.redirected) return;

        if (result.status === "succeeded") {
          window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
          return;
        }
        if (result.status === "processing") {
          window.location.assign(`/checkout/return?order=${orderId}&status=processing&payment=${payment.id}`);
          return;
        }
        // A dismissed dialog leaves the payment at requires_action with no error, so a missing error never means success.
        errorLine.textContent = result.lastPaymentError?.message ?? "The payment step wasn't completed. Try again.";
      });
    </script>
  </body>
</html>
```

### Cliente: JavaScript — `return.html`

```html return.html theme={null}
<!DOCTYPE html>
<html>
  <body>
    <section id="succeeded" hidden>
      <h1>Thanks for your order</h1>
      <p>Payment <span id="payment-id"></span> is complete. A receipt is on its way to your email.</p>
    </section>
    <section id="failed" hidden>
      <h1>Your payment did not go through</h1>
      <p>No money was taken. You can try again with another payment method.</p>
      <a id="retry" href="/checkout">Back to checkout</a>
    </section>
    <section id="pending" hidden>
      <h1>Confirming your payment</h1>
      <p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
    </section>

    <script type="module">
      // Step 3.2: Read the outcome from the URL
      // Whop appends `payment`, `status`, and `client_secret` to your returnUrl. Your own parameters (here `order`) survive.
      const params = new URLSearchParams(window.location.search);
      const paymentId = params.get("payment");
      const status = params.get("status");
      const orderId = params.get("order");

      // Step 3.3: Show the right face
      if (status === "succeeded") {
        document.querySelector("#payment-id").textContent = paymentId;
        document.querySelector("#succeeded").hidden = false;
      } else if (status === "failed" || status === "canceled") {
        document.querySelector("#retry").href = `/checkout?order=${orderId}`;
        document.querySelector("#failed").hidden = false;
      } else {
        document.querySelector("#pending").hidden = false;
      }
    </script>
  </body>
</html>
```

### Servidor: Next.js — `app/api/pay/route.ts`

```typescript app/api/pay/route.ts theme={null}
// Step 2.1: Install the Whop SDK
import { WhopClient } from "@whop/sdk";

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

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

	// Step 2.2: Create the payment from the confirmation token
	const payment = await whop.payments.create({
		account_id: process.env.WHOP_ACCOUNT_ID,
		variant_id: "plan_xxxxxxxxxxxxx",
		confirmation_token: confirmationToken,
		return_url: `https://yoursite.com/checkout/return?order=${orderId}`,
		metadata: { order_id: orderId },
	});

	// client_secret is safe to send to the browser. Your API key never is.
	return Response.json({
		id: payment.id,
		status: payment.status,
		client_secret: payment.client_secret,
	});
}
```

### Servidor: Next.js — `app/api/webhooks/whop/route.ts`

```typescript app/api/webhooks/whop/route.ts theme={null}
import { waitUntil } from "@vercel/functions";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
	// Step 2.3: Fulfill from the webhook
	// Give the raw body. Parsing it first changes the bytes and the signature check fails.
	const payload = await request.text();
	const headers = Object.fromEntries(request.headers);

	const event = unwrapWebhook(payload, {
		headers,
		key: process.env.WHOP_WEBHOOK_SECRET!,
	});

	if (event.type === "payment.succeeded") {
		waitUntil(fulfillOrder(event.data));
	}

	// Respond in less than 5 seconds, or Whop retries.
	return new Response("OK", { status: 200 });
}

async function fulfillOrder(payment: Record<string, any>) {
	// Step 2.3: Fulfill from the webhook
	// metadata.order_id is the value you set when you created the payment.
	const orderId = payment.metadata?.order_id;
	console.log(`[PAYMENT SUCCEEDED] ${payment.id} for order ${orderId}`);
	// Mark the order paid in your database and grant access here.
}
```

### Servidor: Express — `server.ts`

```typescript server.ts theme={null}
// Step 2.1: Install the Whop SDK
import { WhopClient } from "@whop/sdk";
import { unwrapWebhook } from "@whop/sdk/helpers";
import express from "express";

const app = express();

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

app.post("/api/pay", express.json(), async (req, res) => {
	const { confirmationToken, orderId } = req.body;

	// Step 2.2: Create the payment from the confirmation token
	const payment = await whop.payments.create({
		account_id: process.env.WHOP_ACCOUNT_ID,
		variant_id: "plan_xxxxxxxxxxxxx",
		confirmation_token: confirmationToken,
		return_url: `https://yoursite.com/checkout/return?order=${orderId}`,
		metadata: { order_id: orderId },
	});

	// client_secret is safe to send to the browser. Your API key never is.
	res.json({
		id: payment.id,
		status: payment.status,
		client_secret: payment.client_secret,
	});
});

// Step 2.3: Fulfill from the webhook
// Read the raw body on this route only: parsing it first changes the bytes and the signature check fails.
app.post(
	"/api/webhooks/whop",
	express.raw({ type: "application/json" }),
	(req, res) => {
		const event = unwrapWebhook(req.body.toString("utf8"), {
			headers: req.headers,
			key: process.env.WHOP_WEBHOOK_SECRET!,
		});

		if (event.type === "payment.succeeded") {
			// metadata.order_id is the value you set when you created the payment.
			const orderId = event.data.metadata?.order_id;
			console.log(`[PAYMENT SUCCEEDED] ${event.data.id} for order ${orderId}`);
			// Mark the order paid in your database and grant access here.
		}

		// Respond in less than 5 seconds, or Whop retries.
		res.sendStatus(200);
	},
);

app.listen(3000);
```

### Servidor: Python — `server.py`

```python server.py theme={null}
# Step 2.1: Install the Whop SDK
import os

from fastapi import BackgroundTasks, FastAPI, Request, Response
from whop_sdk import Whop
from whop_sdk.lib.verify_webhook import unwrap

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


@app.post("/api/pay")
async def pay(request: Request):
    body = await request.json()

    # Step 2.2: Create the payment from the confirmation token
    payment = client.payments.create(
        request={
            "account_id": os.environ["WHOP_ACCOUNT_ID"],
            "variant_id": "plan_xxxxxxxxxxxxx",
            "confirmation_token": body["confirmationToken"],
            "return_url": f"https://yoursite.com/checkout/return?order={body['orderId']}",
            "metadata": {"order_id": body["orderId"]},
        },
    )

    # client_secret is safe to send to the browser. Your API key never is.
    return {
        "id": payment.id,
        "status": payment.status,
        "client_secret": payment.client_secret,
    }


# Step 2.3: Fulfill from the webhook
@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request, background: BackgroundTasks):
    # Give the raw body. Parsing it first changes the bytes and the signature check fails.
    payload = await request.body()

    event = unwrap(payload, dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "payment.succeeded":
        background.add_task(fulfill_order, event["data"])

    # Respond in less than 5 seconds, or Whop retries.
    return Response(status_code=200)


def fulfill_order(payment):
    # metadata.order_id is the value you set when you created the payment.
    order_id = (payment.get("metadata") or {}).get("order_id")
    print(f"[PAYMENT SUCCEEDED] {payment['id']} for order {order_id}")
    # Mark the order paid in your database and grant access here.
```

## Próximos pasos

* [Referencia de payment elements](https://docs.whop.com/es/elements/latest/payments/overview): cada opción, evento y método del handle de Payments.
* [Express checkout](https://docs.whop.com/es/developer/guides/express-checkout.md): añade Apple Pay y Google Pay con un solo toque junto al formulario.
* [Guardar métodos de pago](https://docs.whop.com/es/developer/guides/save-payment-methods.md): guarda un método sin cobrarlo y cóbralo más tarde desde tu servidor.
* [Integrar un checkout](https://docs.whop.com/es/developer/guides/embed-checkout.md): omite el formulario e inserta el checkout completo de Whop en su lugar.


## Related topics

- [Integra un checkout](https://docs.whop.com/es/developer/guides/embed-checkout.md)
- [Guardar métodos de pago](https://docs.whop.com/es/developer/guides/save-payment-methods.md)
- [Payments](https://docs.whop.com/es/elements/latest/payments/overview.md)
