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

# Acepta pagos únicos

> Acepta pagos únicos con Apple Pay por bienes físicos y servicios del mundo real en tu app de iOS.

[Acepta pagos únicos en iOS con Whop](https://www.youtube.com/embed/K2e_sht1P1I?rel=0)

Usa `Checkout.ApplePayButton` para aceptar pagos únicos por bienes físicos o servicios del mundo real con Apple Pay. Whop procesa los pagos a **2.7% + \$0.30** en lugar de las comisiones del 15–30% de Apple por compras dentro de la app.

> [!TIP]
>
> Para ventas web, usa [enlaces de checkout o el elemento Checkout](https://docs.whop.com/es/developer/guides/accept-payments.md) con **más de 100 métodos de pago** en **195 países**.

> [!WARNING]
>
> **Apple Pay no es para contenido digital.** Usa `Checkout.ApplePayButton` solo si tu app vende bienes físicos (merchandising, comida, hardware) o servicios del mundo real (entradas para eventos, entregas). Las apps que venden contenido digital (funciones premium, suscripciones, moneda dentro de la app, desbloqueo de contenido) deben usar StoreKit. Consulta la sección [Elegibilidad de Apple Pay](https://docs.whop.com/es/developer/guides/ios/checkout-reference.md#apple-pay-eligibility) para más detalles.

## Qué vas a crear

* Una pantalla de detalle de producto con un botón nativo de Apple Pay
* Un flujo de compra que gestiona el éxito, el fallo y la cancelación
* La configuración de variantes en el panel de Whop para tus bienes físicos

## Requisitos previos

* [Instala el SDK WhopCheckout](https://docs.whop.com/es/developer/guides/ios/installation.md)
* Una clave de API restringida a `iap:read`: consulta [Crea una clave de API](https://docs.whop.com/es/developer/guides/ios/installation.md#step-3-create-an-api-key)
* Un producto de Whop con una variante de pago único (consulta el [Paso 5](#step-5-set-up-your-variant))

## Paso 1: Configura el SDK

Inicializa el SDK al iniciar la app. Para bienes físicos de pago único no necesitas la propiedad de compatibilidad `planMappings`: solo se usa para el fallback a StoreKit en las suscripciones.

```swift theme={null}
import SwiftUI
import WhopCheckout

@main
struct DropsApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(Checkout.shared)
                .task {
                    try? await Checkout.shared.configure(
                        // companyId: find in Dashboard URL (starts with biz_)
                        companyId: "biz_xxxxxxxxxxxxxx",
                        // apiKey: create in Dashboard > Developer with iap:read permission
                        apiKey: "your_api_key_here"
                    )
                }
        }
    }
}
```

Consulta la [guía de instalación](https://docs.whop.com/es/developer/guides/ios/installation.md) para ver la configuración completa y las notas de seguridad sobre la clave de API.

## Paso 2: Añade el botón de `Apple Pay`

Coloca `Checkout.ApplePayButton` en la vista de tu producto. El componente renderiza el botón oficial de Apple Pay que cumple las Human Interface Guidelines de Apple; no puedes sustituirlo por un botón con estilo personalizado.

```swift theme={null}
import SwiftUI
import WhopCheckout

struct ProductDetailView: View {
    let product: MerchItem
    @State private var purchaseComplete = false

    var body: some View {
        ScrollView {
            // product image, title, price, size picker...

            Checkout.ApplePayButton(
                // planId: find in Dashboard > Products > [product] > Variants
                planId: product.planId,
                label: .buy,
                onCompletion: { result in
                    switch result {
                    case .success(let purchase):
                        // purchase.receiptId, purchase.membership
                        purchaseComplete = true
                    case .failure(let error):
                        print("Purchase failed: \(error.localizedDescription)")
                    }
                }
            )
            .frame(height: 48)
            .padding(.horizontal)
        }
    }
}
```

Cuando el usuario toca el botón, aparece la hoja nativa de Apple Pay. Face ID o un doble clic confirman, y el pago fluye a través de Whop.

> [!NOTE]
>
> `onCompletion` **no se llama** cuando el usuario cancela: la hoja simplemente se cierra. No hace falta limpiar nada.

## Paso 3: Elige una etiqueta para el botón

El parámetro `label` controla el texto del botón. Elige el que mejor se ajuste a la acción:

| Etiqueta | Texto del botón | Uso |
| - | - | - |
| `.buy` | Buy with Apple Pay | Merchandising de pago único y bienes físicos |
| `.checkout` | Check out with… | Flujos de checkout tipo carrito |
| `.order` | Order with Apple Pay | Comida, entregas, artículos por encargo |
| `.book` | Book with Apple Pay | Reservas, citas, eventos |
| `.continue` | Continue with… | Flujos de varios pasos en los que este no es el último |
| `.plain` | (logotipo de Apple Pay) | Alternativa cuando ningún verbo encaja |

La lista completa proviene de `PayWithApplePayButtonLabel` de Apple: consulta la [documentación de Apple](https://developer.apple.com/documentation/passkit/paywithapplepaybuttonlabel) para ver todas las opciones.

## Paso 4: Gestiona el resultado de la compra

`onCompletion` recibe un `Result<CheckoutPurchaseResult, Error>`. Si tiene éxito, recibes:

| Propiedad | Tipo | Descripción |
| - | - | - |
| `receiptId` | `String` | ID de recibo único de esta compra |
| `membership` | `CheckoutMembership?` | La membresía que Whop creó para la compra |

Úsalo para mostrar una pantalla de confirmación, iniciar el envío o guardar el recibo en tus propios registros.

```swift theme={null}
onCompletion: { result in
    switch result {
    case .success(let purchase):
        // Persist the receipt for your fulfillment flow
        OrderStore.shared.record(
            receiptId: purchase.receiptId,
            membershipId: purchase.membership?.id,
            product: product
        )
        showConfirmation = true
    case .failure(let error):
        showError(error.localizedDescription)
    }
}
```

## Paso 5: Configura tu variante

Cada artículo que se puede comprar necesita una variante en tu panel de Whop:

**1. Crea una variante**

Ve a tu [panel](https://whop.com/dashboard) > Products > selecciona tu producto > **Variants** > **Create variant**.

**2. Configúrala como pago único**

Elige **One-time payment** y establece el precio.

**3. (Opcional) Establece límites de inventario**

Para lanzamientos limitados, establece un tope de stock. El checkout lo aplica automáticamente: cuando se agota el stock, se detienen las compras.

**4. Copia el ID de la variante**

El ID conserva el prefijo `plan_`. Pásalo mediante el parámetro de compatibilidad `Checkout.ApplePayButton(planId:)`.

## Gestiona el fulfillment con webhooks

Para bienes físicos, necesitarás un webhook del lado del servidor que active el envío tras una compra correcta. Escucha el evento `payment.succeeded`:

```typescript theme={null}
import { unwrapWebhook } from "@whop/sdk/helpers";

export async function POST(request: Request) {
  const body = await request.text();
  const headers = Object.fromEntries(request.headers);
  const event = unwrapWebhook(body, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (event.type === "payment.succeeded") {
    // Trigger your shipping/fulfillment flow
    await fulfillOrder(event.data);
  }

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

> [!NOTE]
>
> El callback `onCompletion` del lado del cliente confirma el pago al usuario, pero tu **servidor** debe gestionar el fulfillment mediante webhooks: no dependas solo del cliente. Consulta la [guía de webhooks](https://docs.whop.com/es/developer/guides/webhooks.md) completa para configurarlos.

## Ejemplo completo

Una vista mínima de detalle de merchandising con selección de talla y Apple Pay:

```swift theme={null}
import SwiftUI
import WhopCheckout

struct ProductDetailView: View {
    let product: MerchItem
    @State private var selectedSize: String?
    @State private var showConfirmation = false

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 16) {
                AsyncImage(url: product.imageURL) { image in
                    image.resizable().scaledToFit()
                } placeholder: {
                    Color.gray.opacity(0.1)
                }
                .frame(maxWidth: .infinity)

                Text(product.title)
                    .font(.title)
                    .bold()

                Text(product.price, format: .currency(code: "USD"))
                    .font(.title2)

                // Size picker
                HStack {
                    ForEach(product.sizes, id: \.self) { size in
                        Button(size) {
                            selectedSize = size
                        }
                        .buttonStyle(.bordered)
                        .tint(selectedSize == size ? .accentColor : .secondary)
                    }
                }

                Checkout.ApplePayButton(
                    planId: product.planId,
                    label: .buy,
                    onCompletion: { result in
                        switch result {
                        case .success(let purchase):
                            print("Receipt: \(purchase.receiptId)")
                            showConfirmation = true
                        case .failure(let error):
                            print("Purchase failed: \(error.localizedDescription)")
                        }
                    }
                )
                .frame(height: 48)
                .disabled(selectedSize == nil)
            }
            .padding()
        }
        .sheet(isPresented: $showConfirmation) {
            OrderConfirmationView(product: product, size: selectedSize ?? "")
        }
    }
}
```

## Próximos pasos

> [card] [Webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Gestiona eventos de pago y activa el fulfillment

> [card] [Elegibilidad de Apple Pay](https://docs.whop.com/es/developer/guides/ios/checkout-reference.md#apple-pay-eligibility)
>
> Confirma que tu app cumple los requisitos de las App Store Review Guidelines

> [card] [Crea un paywall](https://docs.whop.com/es/developer/guides/ios/build-a-paywall.md)
>
> Vende suscripciones en lugar de compras únicas

> [card] [Referencia de la API](https://docs.whop.com/es/developer/guides/ios/checkout-reference.md)
>
> Documentación completa del SDK


## 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)
- [Membresías](https://docs.whop.com/es/developer/guides/memberships.md)
