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

# Referencia del SDK de Checkout para iOS

> Referencia de las clases, los métodos y los tipos del SDK WhopCheckout para iOS.

Esta página documenta todas las clases, métodos, propiedades y tipos disponibles en el SDK WhopCheckout.

> [!NOTE]
>
> Para ver guías, consulta [Crea un
> paywall](https://docs.whop.com/es/developer/guides/ios/build-a-paywall.md) o [Comprueba los
> entitlements](https://docs.whop.com/es/developer/guides/ios/check-entitlements.md).

## Checkout

La clase principal para gestionar las compras dentro de la app. El sistema de entorno de SwiftUI puede usar esta clase `@Observable`.

```swift theme={null}
@MainActor @Observable
public class Checkout
```

***

### `shared`

La instancia compartida de Checkout. Usa este singleton para configurar el SDK y gestionar las compras.

```swift theme={null}
static let shared: Checkout
```

**Ejemplo:**

```swift theme={null}
import WhopCheckout

// Configure at app startup
try await Checkout.shared.configure(...)

// Pass through SwiftUI environment
ContentView()
    .environment(Checkout.shared)

// Access in views
@Environment(Checkout.self) var checkout
```

***

### configure(companyId:apiKey:planMappings:)

Configura e inicializa el SDK. Llámalo una vez al iniciar la app.

```swift theme={null}
func configure(
    companyId: String,
    apiKey: String,
    planMappings: [PlanMapping] = []
) async throws
```

**Parámetros:**

| Parámetro | Tipo | Descripción |
| - | - | - |
| `companyId` | `String` | El ID de tu cuenta de Whop (empieza por `biz_`) |
| `apiKey` | `String` | Tu clave de API. Dale solo el alcance `iap:read`: consulta [Crea una clave de API](https://docs.whop.com/es/developer/guides/ios/installation.md#step-3-create-an-api-key) para saber por qué es seguro incluirla en tu app. |
| `planMappings` | `[PlanMapping]` | Propiedad de compatibilidad que asigna los IDs de variantes de Whop a los IDs de producto de Apple StoreKit. Pasa un array vacío si no necesitas el fallback a StoreKit. |

**Ejemplo:**

```swift theme={null}
try await Checkout.shared.configure(
    companyId: "biz_xxxxxxxxxxxxxx",
    apiKey: "your_api_key_here",
    planMappings: [
        .init(whopId: "plan_xxxxx", appleId: "monthly_sub"),
        .init(whopId: "plan_yyyyy", appleId: "yearly_sub")
    ]
)
```

***

### isInitialized

Indica si el SDK ha terminado de inicializarse.

```swift theme={null}
var isInitialized: Bool { get }
```

**Ejemplo:**

```swift theme={null}
if checkout.isInitialized {
    // SDK ready to use
}
```

***

### deviceId

El identificador único de dispositivo que gestiona el SDK. Persiste entre inicios de la app gracias al Keychain de iOS.

```swift theme={null}
var deviceId: String { get }
```

***

### appUserId

El ID del usuario actual, o `nil` si es un invitado.

```swift theme={null}
var appUserId: String? { get }
```

***

### `plans`

Propiedad de compatibilidad que contiene las variantes de suscripción disponibles para los productos configurados.

```swift theme={null}
var plans: [CheckoutPlan] { get }
```

**Ejemplo:**

```swift theme={null}
ForEach(checkout.plans) { plan in
    Text(plan.title ?? "Variant")
}
```

***

### `memberships`

Array de membresías activas del usuario o dispositivo actual.

```swift theme={null}
var memberships: [CheckoutMembership] { get }
```

***

### `isSubscribed`

Indica si el usuario tiene alguna membresía activa.

```swift theme={null}
var isSubscribed: Bool { get }
```

**Ejemplo:**

```swift theme={null}
if checkout.isSubscribed {
    // Show premium content
}
```

***

### `supportsExternalPurchases`

Indica si la región actual de la App Store admite compras externas (no de StoreKit). Actualmente es `true` para usuarios de Estados Unidos y `false` en el resto del mundo.

```swift theme={null}
var supportsExternalPurchases: Bool { get }
```

Cuando es `true`, el SDK usa de forma predeterminada el checkout web de Whop (comisiones más bajas). Cuando es `false`, usa de forma predeterminada StoreKit.

***

### `refreshPlans()`

Actualiza desde el servidor las variantes disponibles.

```swift theme={null}
@discardableResult
func refreshPlans() async throws -> [CheckoutPlan]
```

**Devuelve:** las variantes actualizadas con los precios vigentes.

**Lanza:** `WhopCheckoutError` si la actualización falla.

Llámalo para actualizar los precios o la disponibilidad de las variantes después de la inicialización. También actualiza la propiedad de compatibilidad `plans` con los datos más recientes.

**Ejemplo:**

```swift theme={null}
// Refresh and use the return value
let plans = try await Checkout.shared.refreshPlans()

// Or just refresh (plans property updates automatically)
try await Checkout.shared.refreshPlans()
```

***

### `hasAccess(to:)`

Comprueba si el usuario tiene acceso a un producto específico.

```swift theme={null}
func hasAccess(to productId: String) -> Bool
```

**Parámetros:**

| Parámetro | Tipo | Descripción |
| - | - | - |
| `productId` | `String` | El ID del producto que se comprueba (empieza por `prod_`) |

**Devuelve:** `true` si el usuario tiene una membresía activa para el producto

**Ejemplo:**

```swift theme={null}
// Replace with your product ID from the Whop dashboard
if checkout.hasAccess(to: "prod_xxxxxxxxxxxxxx") {
    // Show pro features
}
```

***

### purchase(\_:method:)

Inicia un flujo de compra para una variante. De forma predeterminada, usa el checkout web de Whop en Estados Unidos (comisiones más bajas) y StoreKit en el resto del mundo.

```swift theme={null}
func purchase(_ whopPlanId: String, method: PaymentMethod? = nil) async throws -> CheckoutPurchaseResult
```

**Parámetros:**

| Parámetro | Tipo | Descripción |
| - | - | - |
| `whopPlanId` | `String` | El ID de la variante de Whop que se compra (conserva el prefijo `plan_`) |
| `method` | `PaymentMethod?` | Sustituye el método de pago. El valor predeterminado depende de la región. |

**Devuelve:** `CheckoutPurchaseResult`, que contiene el ID del recibo y la información de la membresía

**Lanza:**

* `WhopCheckoutError.cancelled` si el usuario cierra el checkout
* `WhopCheckoutError.notConfigured` si el SDK no está configurado
* `WhopCheckoutError.paymentFailed(String)` si el pago falla

**Ejemplo:**

```swift theme={null}
do {
    // Use default payment method (Whop in US, StoreKit elsewhere)
    let result = try await checkout.purchase("plan_xxxxxxxxxxxxxx")
    print("Success! Receipt: \(result.receiptId)")
} catch WhopCheckoutError.cancelled {
    // User cancelled
} catch {
    // Handle error
}

// Or explicitly choose a payment method
let result = try await checkout.purchase("plan_xxx", method: .storeKit)
```

> [!NOTE]
>
> Para Apple Pay, usa [`Checkout.ApplePayButton`](#checkout-applepaybutton), o
> [`presentApplePay(_:)`](#presentapplepay-_) cuando tu interfaz active Apple Pay
> desde una interacción personalizada.

***

### logIn(appUserId:)

Inicia la sesión de un usuario y reclama las membresías no reclamadas asociadas al dispositivo.

```swift theme={null}
func logIn(appUserId: String) async throws
```

**Parámetros:**

| Parámetro | Tipo | Descripción |
| - | - | - |
| `appUserId` | `String` | El ID de usuario de tu app (no debería cambiar para el mismo usuario) |

**Ejemplo:**

```swift theme={null}
try await checkout.logIn(appUserId: "user_123")
```

***

### `logOut()`

Cierra la sesión del usuario actual y borra sus membresías del estado local.

```swift theme={null}
func logOut()
```

**Ejemplo:**

```swift theme={null}
checkout.logOut()
```

***

### `restorePurchases()`

Restaura las compras tanto de StoreKit como de Whop.

```swift theme={null}
func restorePurchases() async throws -> Bool
```

**Devuelve:** `true` si el SDK encontró una suscripción activa

**Ejemplo:**

```swift theme={null}
Button("Restore Purchases") {
    Task {
        let restored = try await checkout.restorePurchases()
        if restored {
            print("Purchases restored!")
        }
    }
}
```

***

## Tipos

### `CheckoutPurchaseResult`

El resultado de una compra correcta.

```swift theme={null}
struct CheckoutPurchaseResult {
    let receiptId: String
    let membership: CheckoutMembership?
}
```

| Propiedad | Tipo | Descripción |
| - | - | - |
| `receiptId` | `String` | El ID de recibo único de esta compra |
| `membership` | `CheckoutMembership?` | La membresía creada por esta compra |

> [accordion] ¿Cuándo es nil la membresía?
>
> La propiedad `membership` depende del método de pago utilizado:
>
> | Método de pago | Región | Valor de `membership` |
> | - | - | - |
> | Checkout web de Whop | EE. UU. | Se rellena de inmediato |
> | StoreKit | Fuera de EE. UU. | `nil` al principio |
>
> **Por qué las compras de StoreKit devuelven nil:**
> Apple procesa las transacciones de StoreKit de forma asíncrona. Cuando se completa la compra, es posible que el SDK aún no haya sincronizado la membresía de Whop. El SDK también registra los entitlements de StoreKit, así que `checkout.isSubscribed` seguirá devolviendo `true`.
>
> **Cómo gestionar ambos casos:**
>
> ```swift theme={null}
> do {
>     let result = try await checkout.purchase("plan_xxx")
>
>     // Always check isSubscribed - works for both payment methods
>     if checkout.isSubscribed {
>         // Grant access
>     }
>
>     // Optionally use membership details if available
>     if let membership = result.membership {
>         print("Membership ID: \(membership.id)")
>         print("Expires: \(membership.expiresAt?.formatted() ?? "N/A")")
>     }
> } catch WhopCheckoutError.cancelled {
>     // User cancelled
> }
> ```
>
> **Punto clave:** no dependas de que `membership` no sea nil para conceder acceso. Usa siempre `checkout.isSubscribed` o `checkout.hasAccess(to:)` para comprobar el estado de la suscripción.

***

### `PlanMapping`

Una asignación entre una variante de Whop y un producto de Apple StoreKit, que se usa durante la configuración del SDK. Indica al SDK qué producto de Apple usar para las compras de StoreKit fuera de Estados Unidos.

> [!NOTE]
>
> **PlanMapping frente a CheckoutPlan:** `PlanMapping` sirve para la configuración del SDK
> (asignación de IDs). `CheckoutPlan` es lo que muestras en tu interfaz (tiene precios,
> títulos, etc.). Creas objetos `PlanMapping` en `configure()` y luego accedes a los
> objetos `CheckoutPlan` mediante `checkout.plans`.

```swift theme={null}
struct PlanMapping: Sendable {
    let whopId: String
    let appleId: String

    init(whopId: String, appleId: String)
}
```

| Propiedad | Tipo | Descripción |
| - | - | - |
| `whopId` | `String` | El ID de la variante de Whop (p. ej., `plan_xxx`) |
| `appleId` | `String` | El ID de producto de Apple de App Store Connect (p. ej., `com.yourapp.monthly`) |

**Ejemplo:**

```swift theme={null}
// Used in configure() - just maps IDs
try await Checkout.shared.configure(
    companyId: "biz_xxx",
    apiKey: "your_key",
    planMappings: [
        .init(whopId: "plan_monthly", appleId: "com.app.monthly"),
        .init(whopId: "plan_yearly", appleId: "com.app.yearly")
    ]
)

// After configuration, use the compatibility checkout.plans property for UI
ForEach(checkout.plans) { plan in  // These are CheckoutPlan objects
    Text(plan.title ?? "Variant")
    Text(plan.whopDisplayPrice)
}
```

> [!TIP]
>
> Tus variantes de Whop y tus productos de Apple deben tener precios y periodos
> de facturación equivalentes. Consulta [`PlanMapping`](#planmapping) para ver los detalles de la API de compatibilidad.

***

### `PaymentMethod`

El método de pago que se usa para una compra.

```swift theme={null}
enum PaymentMethod: Sendable {
    case whop      // Web checkout via Whop (lower fees)
    case storeKit  // StoreKit in-app purchase via the App Store
}
```

| Caso | Descripción |
| - | - |
| `whop` | Checkout web a través de Whop. Comisiones del 2.7% + \$0.30 (frente al 15-30% de Apple). Disponible en Estados Unidos. |
| `storeKit` | Compra dentro de la app con StoreKit a través de la App Store (comisiones del 15-30%). Se usa como alternativa fuera de Estados Unidos. |

> [!NOTE]
>
> Apple Pay no está incluido en `PaymentMethod`: tiene sus propias superficies:
> [`Checkout.ApplePayButton`](#checkout-applepaybutton) y
> [`presentApplePay(_:)`](#presentapplepay-_).

***

### `Checkout.ApplePayButton`

Una vista de SwiftUI prediseñada que renderiza el botón oficial de Apple Pay y gestiona todo el flujo de compra. **Debes usar este componente** (o `PKPaymentButton` / `PayWithApplePayButton`) cuando ofrezcas Apple Pay: las Human Interface Guidelines de Apple no permiten botones con estilo personalizado.

```swift theme={null}
struct ApplePayButton: View {
    init(
        planId: String,
        label: PayWithApplePayButtonLabel = .plain,
        onCompletion: @escaping (Result<CheckoutPurchaseResult, Error>) -> Void
    )
}
```

**Parámetros:**

| Parámetro | Tipo | Descripción |
| - | - | - |
| `planId` | `String` | El ID de la variante de Whop que se compra |
| `label` | `PayWithApplePayButtonLabel` | Estilo de la etiqueta del botón: `.plain`, `.buy`, `.subscribe`, `.checkout`, `.book`, `.order`, etc. |
| `onCompletion` | `(Result) -> Void` | Se llama en caso de éxito o fallo. **No se llama** cuando el usuario cancela. |

**Ejemplo:**

```swift theme={null}
Checkout.ApplePayButton(planId: "plan_xxx", label: .subscribe) { result in
    switch result {
    case .success(let purchase):
        print("Receipt: \(purchase.receiptId)")
    case .failure(let error):
        showError(error.localizedDescription)
    }
}
.frame(height: 48)
```

> [!WARNING]
>
> **Apple Pay no es para contenido digital.** Usa `Checkout.ApplePayButton` solo
> si tu app vende bienes físicos o servicios del mundo real. Las apps que venden contenido
> digital (suscripciones a funciones premium, moneda dentro de la app, etc.) deben usar
> StoreKit. Consulta la sección [Elegibilidad de Apple Pay](#apple-pay-eligibility)
> más abajo.

### `presentApplePay(_:)`

Presenta la hoja de Apple Pay directamente, para interfaces que inician Apple Pay desde una interacción personalizada (por ejemplo, un control de deslizar para pagar) en lugar del botón prediseñado.

```swift theme={null}
func presentApplePay(_ planId: String) async throws -> CheckoutPurchaseResult
```

Llámalo solo como respuesta directa a una interacción del usuario: Apple solo permite presentar una hoja de pago cuando el usuario ha pedido pagar de forma explícita. Lanza `WhopCheckoutError.cancelled` cuando el usuario cierra la hoja.

```swift theme={null}
let result = try await checkout.presentApplePay("plan_xxx")
```

Se aplican las mismas reglas de [elegibilidad de Apple Pay](#apple-pay-eligibility) que para `Checkout.ApplePayButton`.

***

### Modelo de visualización `CheckoutPlan`

Una variante de suscripción disponible para comprar, a la que se accede mediante la propiedad de compatibilidad `checkout.plans`. Úsala para mostrar la información de la variante en tu interfaz y para realizar compras.

> [!NOTE]
>
> **Tipos de compatibilidad:** `CheckoutPlan` contiene todos los detalles de la variante (precios,
> títulos, información de la prueba) para tu interfaz. `Plan` es una asignación de IDs que se usa durante la configuración
> del SDK. Nunca creas objetos `CheckoutPlan`: provienen de
> `checkout.plans` después de la configuración.

```swift theme={null}
struct CheckoutPlan: Identifiable {
    let id: String
    let productId: String?
    let title: String?
    let description: String?
    let planType: PlanType
    let billingPeriodDays: Int?
    let baseCurrency: String
    let initialPrice: Double
    let renewalPrice: Double
    let trialPeriodDays: Int?

    var renewalPeriod: RenewalPeriod? { get }
    var whopDisplayPrice: String { get }
    var appleDisplayPrice: String? { get }
}

enum PlanType: String {
    case oneTime = "one_time"
    case renewal
    case unknown
}

enum RenewalPeriod: Equatable {
    case weekly      // 7 days
    case monthly     // 30 days
    case quarterly   // 90 days
    case semiAnnual  // 180 days
    case yearly      // 365 days
    case custom(Int) // Custom period in days
}
```

| Propiedad | Tipo | Descripción |
| - | - | - |
| `id` | `String` | El ID de la variante |
| `productId` | `String?` | El producto al que pertenece esta variante |
| `title` | `String?` | Nombre visible de la variante |
| `description` | `String?` | Texto descriptivo de la variante |
| `planType` | `PlanType` | Si es una variante de pago único o recurrente |
| `billingPeriodDays` | `Int?` | Número de días del ciclo de facturación (30 = mensual, 365 = anual) |
| `baseCurrency` | `String` | Código de moneda (p. ej., `usd`) |
| `initialPrice` | `Double` | Precio inicial de la variante |
| `renewalPrice` | `Double` | Precio de las renovaciones |
| `trialPeriodDays` | `Int?` | Número de días del periodo de prueba |
| `renewalPeriod` | `RenewalPeriod?` | Periodo de renovación calculado (`.monthly`, `.yearly`, etc.) |
| `whopDisplayPrice` | `String` | Precio de Whop formateado (p. ej., "\$9.99") |
| `appleDisplayPrice` | `String?` | Precio localizado de StoreKit, si existe una asignación de variante |

***

### `CheckoutMembership`

Una membresía de suscripción activa.

```swift theme={null}
struct CheckoutMembership: Identifiable {
    let id: String
    let productId: String
    let planId: String
    let status: Status
    let isClaimed: Bool
    let createdAt: Date
    let expiresAt: Date?
    let renewalPeriodEnd: Date?
    let cancelAtPeriodEnd: Bool
    let receiptId: String?

    var isActive: Bool { get }
}

enum Status: String {
    case active
    case canceled
    case canceling
    case completed
    case drafted
    case expired
    case pastDue = "past_due"
    case trialing
    case unresolved
    case unknown
}
```

| Propiedad | Tipo | Descripción |
| - | - | - |
| `id` | `String` | El ID de la membresía |
| `productId` | `String` | El producto al que pertenece esta membresía |
| `planId` | `String` | Campo de compatibilidad que contiene el ID de la variante de esta membresía |
| `status` | `Status` | Estado actual de la membresía |
| `isActive` | `Bool` | Si la membresía concede acceso (true para `active`, `trialing`, `canceling`, `pastDue`, `completed`) |
| `isClaimed` | `Bool` | Si un usuario ha reclamado la membresía |
| `createdAt` | `Date` | Cuándo creó Whop la membresía |
| `expiresAt` | `Date?` | Cuándo caduca la membresía |
| `renewalPeriodEnd` | `Date?` | Fin del periodo de renovación actual |
| `cancelAtPeriodEnd` | `Bool` | Si la membresía se cancelará al final del periodo |
| `receiptId` | `String?` | El ID del recibo de esta membresía |

***

### WhopCheckoutError

Errores que lanza el SDK.

```swift theme={null}
enum WhopCheckoutError: Error {
    case cancelled
    case notConfigured
    case paymentFailed(String)
}
```

| Caso | Descripción |
| - | - |
| `cancelled` | El usuario cerró la hoja de checkout sin completar la compra |
| `notConfigured` | El SDK no está configurado. Llama primero a `Checkout.shared.configure()`. |
| `paymentFailed(String)` | El pago falló. La cadena asociada contiene el mensaje de error. |

***

## Elegibilidad de `Apple Pay`

> [!WARNING]
>
> **La mayoría de las apps no deberían usar Apple Pay.** Apple Pay a través del SDK WhopCheckout es
> solo para apps que venden bienes físicos o servicios del mundo real, no contenido
> digital, suscripciones a funciones de la app ni moneda dentro de la app.

### Directrices de revisión de la `App Store`

La [App Store Review Guideline 3.1.1](https://developer.apple.com/app-store/review/guidelines/#in-app-purchase) de Apple exige que los **bienes y servicios digitales** (funciones premium, suscripciones, desbloqueo de contenido, moneda virtual) usen In-App Purchase (StoreKit). Apple Pay está explícitamente prohibido para estas transacciones.

La [Guideline 3.1.3(e)](https://developer.apple.com/app-store/review/guidelines/#multiplatform-services) y las [directrices de Apple Pay](https://developer.apple.com/apple-pay/) permiten Apple Pay para comprar **bienes físicos y servicios del mundo real**.

### Apps que cumplen los requisitos

Apps que **pueden** usar Apple Pay (`Checkout.ApplePayButton`):

| Categoría | Ejemplos |
| - | - |
| Comercio electrónico | Ropa, electrónica, merchandising físico |
| Comida y entregas | Entrega de comida, pedidos de supermercado |
| Transporte | Servicios de transporte con conductor, alquiler de coches, aparcamiento |
| Viajes y hostelería | Reservas de hotel, billetes de avión, entradas para eventos |
| Servicios profesionales | Sesiones de tutoría, consultoría, reservas de reparaciones del hogar |
| Fitness y bienestar | Reservas de clases presenciales, sesiones de entrenamiento personal |

Apps que **deben** usar StoreKit (`.storeKit`) o el checkout web de Whop (`.whop`):

| Categoría | Ejemplos |
| - | - |
| Suscripciones digitales | Funciones premium de la app, niveles pro |
| Contenido digital | Libros electrónicos, música, streaming de vídeo |
| Bienes virtuales | Moneda dentro de la app, artículos cosméticos, potenciadores |
| Cursos online | Cursos en vídeo, talleres digitales |
| Funciones SaaS | Ampliaciones de almacenamiento en la nube, niveles de acceso a la API |

### Cómo elegir

```
Is the user paying for a physical good or real-world service?
├── YES → You can use Checkout.ApplePayButton (or .whop / .storeKit)
└── NO  → You must use .whop or .storeKit (not Apple Pay)
```

Si tu app cumple los requisitos, usa `Checkout.ApplePayButton`. Si no estás seguro de si tu app cumple los requisitos, usa de forma predeterminada `.whop` (Estados Unidos) o `.storeKit` (resto del mundo). El SDK lo gestiona automáticamente cuando llamas a `purchase()` sin especificar un método.

***

## Requisitos

* iOS 17.0+
* Xcode 15.0+
* Swift 5.10+


## Related topics

- [SDK de Checkout para iOS](https://docs.whop.com/es/developer/guides/ios/overview.md)
- [Instala los SDKs de Whop para iOS](https://docs.whop.com/es/developer/guides/ios/installation.md)
- [Crea un paywall para iOS](https://docs.whop.com/es/developer/guides/ios/build-a-paywall.md)
