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

# Referentie voor de iOS Checkout SDK

> Referentie voor de klassen, methoden en typen in de WhopCheckout iOS-SDK.

Deze pagina documenteert alle klassen, methoden, eigenschappen en typen die beschikbaar zijn in de WhopCheckout-SDK.

> [!NOTE]
>
> Zie voor gidsen [Een
> paywall bouwen](https://docs.whop.com/nl/developer/guides/ios/build-a-paywall.md) of [Rechten
> controleren](https://docs.whop.com/nl/developer/guides/ios/check-entitlements.md).

## Checkout

De hoofdklasse voor het beheren van in-app-aankopen. Het environment-systeem van SwiftUI kan deze `@Observable`-klasse gebruiken.

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

***

### `shared`

De gedeelde Checkout-instantie. Gebruik deze singleton om de SDK te configureren en aankopen te beheren.

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

**Voorbeeld:**

```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:)

Configureert en initialiseert de SDK. Roep dit één keer aan bij het opstarten van de app.

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

**Parameters:**

| Parameter | Type | Beschrijving |
| - | - | - |
| `companyId` | `String` | Je Whop-account-ID (begint met `biz_`) |
| `apiKey` | `String` | Je API-sleutel. Geef deze alleen de scope `iap:read`; zie [Een API-sleutel aanmaken](https://docs.whop.com/nl/developer/guides/ios/installation.md#step-3-create-an-api-key) voor waarom deze veilig in je app kan worden ingesloten. |
| `planMappings` | `[PlanMapping]` | Compatibiliteitseigenschap die Whop-variant-ID's koppelt aan product-ID's van Apple StoreKit. Geef een lege array mee als je geen StoreKit-fallback nodig hebt. |

**Voorbeeld:**

```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

Geeft aan of de SDK klaar is met initialiseren.

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

**Voorbeeld:**

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

***

### deviceId

De unieke apparaat-ID die door de SDK wordt beheerd. Blijft via de iOS-sleutelhanger behouden tussen het opstarten van de app.

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

***

### appUserId

Het ID van de huidige gebruiker, of `nil` voor een gast.

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

***

### `plans`

Compatibiliteitseigenschap met de beschikbare abonnementsvarianten voor de geconfigureerde producten.

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

**Voorbeeld:**

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

***

### `memberships`

Array met actieve lidmaatschappen voor de huidige gebruiker of het huidige apparaat.

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

***

### `isSubscribed`

Of de gebruiker een actief lidmaatschap heeft.

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

**Voorbeeld:**

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

***

### `supportsExternalPurchases`

Of de huidige App Store-regio externe aankopen (niet via StoreKit) ondersteunt. Momenteel `true` voor gebruikers in de Verenigde Staten en elders `false`.

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

Bij `true` gebruikt de SDK standaard de webcheckout van Whop (lagere kosten). Bij `false` gebruikt de SDK standaard StoreKit.

***

### `refreshPlans()`

Vernieuwt de beschikbare varianten vanaf de server.

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

**Retourneert:** de vernieuwde varianten met actuele prijzen.

**Genereert:** `WhopCheckoutError` als het vernieuwen mislukt.

Roep dit aan om prijzen of de beschikbaarheid van varianten na de initialisatie bij te werken. Dit werkt ook de compatibiliteitseigenschap `plans` bij met de nieuwste gegevens.

**Voorbeeld:**

```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:)`

Controleert of de gebruiker toegang heeft tot een specifiek product.

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

**Parameters:**

| Parameter | Type | Beschrijving |
| - | - | - |
| `productId` | `String` | Het product-ID om te controleren (begint met `prod_`) |

**Retourneert:** `true` als de gebruiker een actief lidmaatschap voor het product heeft

**Voorbeeld:**

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

***

### purchase(\_:method:)

Start een aankoopflow voor een variant. Gebruikt standaard de webcheckout van Whop in de Verenigde Staten (lagere kosten) en elders StoreKit.

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

**Parameters:**

| Parameter | Type | Beschrijving |
| - | - | - |
| `whopPlanId` | `String` | Het Whop-variant-ID om te kopen (behoudt het voorvoegsel `plan_`) |
| `method` | `PaymentMethod?` | Overschrijf de betaalmethode. De standaard hangt af van de regio. |

**Retourneert:** `CheckoutPurchaseResult` met de bon-ID en lidmaatschapsgegevens

**Genereert:**

* `WhopCheckoutError.cancelled` als de gebruiker de checkout sluit
* `WhopCheckoutError.notConfigured` als de SDK niet is geconfigureerd
* `WhopCheckoutError.paymentFailed(String)` als de betaling mislukt

**Voorbeeld:**

```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]
>
> Gebruik voor Apple Pay [`Checkout.ApplePayButton`](#checkout-applepaybutton), of
> [`presentApplePay(_:)`](#presentapplepay-_) wanneer je UI Apple Pay activeert
> vanuit een aangepaste interactie.

***

### logIn(appUserId:)

Logt een gebruiker in en claimt alle niet-geclaimde lidmaatschappen die aan het apparaat zijn gekoppeld.

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

**Parameters:**

| Parameter | Type | Beschrijving |
| - | - | - |
| `appUserId` | `String` | Het gebruikers-ID van je app (mag niet veranderen voor dezelfde gebruiker) |

**Voorbeeld:**

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

***

### `logOut()`

Logt de huidige gebruiker uit en wist diens lidmaatschappen uit de lokale status.

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

**Voorbeeld:**

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

***

### `restorePurchases()`

Herstelt aankopen van zowel StoreKit als Whop.

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

**Retourneert:** `true` als de SDK een actief abonnement heeft gevonden

**Voorbeeld:**

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

***

## Typen

### `CheckoutPurchaseResult`

Het resultaat van een geslaagde aankoop.

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

| Eigenschap | Type | Beschrijving |
| - | - | - |
| `receiptId` | `String` | De unieke bon-ID voor deze aankoop |
| `membership` | `CheckoutMembership?` | Het lidmaatschap dat door deze aankoop is aangemaakt |

> [accordion] Wanneer is membership nil?
>
> De eigenschap `membership` hangt af van de gebruikte betaalmethode:
>
> | Betaalmethode | Regio | Waarde van `membership` |
> | - | - | - |
> | Whop-webcheckout | VS | Direct gevuld |
> | StoreKit | Buiten de VS | Aanvankelijk `nil` |
>
> **Waarom StoreKit-aankopen nil retourneren:**
> StoreKit-transacties worden asynchroon door Apple verwerkt. Wanneer de aankoop is voltooid, heeft de SDK het Whop-lidmaatschap mogelijk nog niet gesynchroniseerd. De SDK houdt ook StoreKit-rechten bij, dus `checkout.isSubscribed` retourneert nog steeds `true`.
>
> **Hoe je beide gevallen afhandelt:**
>
> ```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
> }
> ```
>
> **Belangrijk:** vertrouw er niet op dat `membership` niet nil is om toegang te verlenen. Gebruik altijd `checkout.isSubscribed` of `checkout.hasAccess(to:)` om de abonnementsstatus te controleren.

***

### `PlanMapping`

Een koppeling tussen een Whop-variant en een Apple StoreKit-product, gebruikt tijdens de SDK-configuratie. Hiermee weet de SDK welk Apple-product moet worden gebruikt voor StoreKit-aankopen buiten de Verenigde Staten.

> [!NOTE]
>
> **PlanMapping vs. CheckoutPlan:** `PlanMapping` is voor de SDK-configuratie
> (ID's koppelen). `CheckoutPlan` is wat je in je UI toont (met prijzen,
> titels enzovoort). Je maakt `PlanMapping`-objecten aan in `configure()` en opent daarna
> `CheckoutPlan`-objecten via `checkout.plans`.

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

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

| Eigenschap | Type | Beschrijving |
| - | - | - |
| `whopId` | `String` | Het Whop-variant-ID (bijv. `plan_xxx`) |
| `appleId` | `String` | Het Apple-product-ID uit App Store Connect (bijv. `com.yourapp.monthly`) |

**Voorbeeld:**

```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]
>
> Je Whop-varianten en Apple-producten moeten overeenkomende prijzen en
> factureringsperioden hebben. Zie [`PlanMapping`](#planmapping) voor details over de compatibiliteits-API.

***

### `PaymentMethod`

De betaalmethode die voor een aankoop wordt gebruikt.

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

| Case | Beschrijving |
| - | - |
| `whop` | Webcheckout via Whop. Kosten van 2,7% + \$0,30 (tegenover 15-30% bij Apple). Beschikbaar in de Verenigde Staten. |
| `storeKit` | StoreKit-in-app-aankoop via de App Store (kosten van 15-30%). Gebruikt als fallback buiten de Verenigde Staten. |

> [!NOTE]
>
> Apple Pay is niet opgenomen in `PaymentMethod`; het heeft eigen onderdelen:
> [`Checkout.ApplePayButton`](#checkout-applepaybutton) en
> [`presentApplePay(_:)`](#presentapplepay-_).

***

### `Checkout.ApplePayButton`

Een kant-en-klare SwiftUI-weergave die de officiële Apple Pay-knop van Apple rendert en de volledige aankoopflow afhandelt. **Je moet deze component gebruiken** (of `PKPaymentButton` / `PayWithApplePayButton`) wanneer je Apple Pay aanbiedt; knoppen met een aangepaste stijl zijn niet toegestaan volgens de Human Interface Guidelines van Apple.

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

**Parameters:**

| Parameter | Type | Beschrijving |
| - | - | - |
| `planId` | `String` | Het Whop-variant-ID om te kopen |
| `label` | `PayWithApplePayButtonLabel` | Stijl van het knoplabel: `.plain`, `.buy`, `.subscribe`, `.checkout`, `.book`, `.order`, enz. |
| `onCompletion` | `(Result) -> Void` | Aangeroepen bij succes of mislukking. **Niet aangeroepen** wanneer de gebruiker annuleert. |

**Voorbeeld:**

```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 is niet bedoeld voor digitale content.** Gebruik `Checkout.ApplePayButton`
> alleen als je app fysieke goederen of diensten in de echte wereld verkoopt. Apps die digitale
> content verkopen (abonnementen op premiumfuncties, in-app-valuta, enz.) moeten
> StoreKit gebruiken. Zie de sectie [Geschiktheid voor Apple Pay](#apple-pay-eligibility)
> hieronder.

### `presentApplePay(_:)`

Toont het Apple Pay-venster direct, voor UI's die Apple Pay starten vanuit een aangepaste interactie (bijvoorbeeld een schuif-om-te-betalen-besturingselement) in plaats van de kant-en-klare knop.

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

Roep dit alleen aan als directe reactie op een gebruikersinteractie; Apple staat het tonen van een betalingsvenster alleen toe wanneer de gebruiker expliciet heeft gevraagd om te betalen. Genereert `WhopCheckoutError.cancelled` wanneer de gebruiker het venster sluit.

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

Dezelfde regels voor [geschiktheid voor Apple Pay](#apple-pay-eligibility) gelden als voor `Checkout.ApplePayButton`.

***

### `CheckoutPlan`-weergavemodel

Een abonnementsvariant die te koop is, toegankelijk via de compatibiliteitseigenschap `checkout.plans`. Gebruik dit om variantinformatie in je UI te tonen en om aankopen te doen.

> [!NOTE]
>
> **Compatibiliteitstypen:** `CheckoutPlan` bevat volledige variantgegevens (prijzen,
> titels, proefperiode-informatie) voor je UI. `Plan` is een ID-koppeling die tijdens de SDK-
> configuratie wordt gebruikt. Je maakt nooit zelf `CheckoutPlan`-objecten aan; ze komen uit
> `checkout.plans` na de configuratie.

```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
}
```

| Eigenschap | Type | Beschrijving |
| - | - | - |
| `id` | `String` | Het variant-ID |
| `productId` | `String?` | Het product waartoe deze variant behoort |
| `title` | `String?` | Weergavenaam van de variant |
| `description` | `String?` | Beschrijvingstekst voor de variant |
| `planType` | `PlanType` | Of dit een eenmalige of terugkerende variant is |
| `billingPeriodDays` | `Int?` | Aantal dagen in de factureringscyclus (30 = maandelijks, 365 = jaarlijks) |
| `baseCurrency` | `String` | Valutacode (bijv. `usd`) |
| `initialPrice` | `Double` | Startprijs van de variant |
| `renewalPrice` | `Double` | Prijs voor verlengingen |
| `trialPeriodDays` | `Int?` | Aantal dagen in de proefperiode |
| `renewalPeriod` | `RenewalPeriod?` | Berekende verlengingsperiode (`.monthly`, `.yearly`, enz.) |
| `whopDisplayPrice` | `String` | Opgemaakte Whop-prijs (bijv. "\$9.99") |
| `appleDisplayPrice` | `String?` | Gelokaliseerde StoreKit-prijs, als er een variantkoppeling bestaat |

***

### `CheckoutMembership`

Een actief abonnementslidmaatschap.

```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
}
```

| Eigenschap | Type | Beschrijving |
| - | - | - |
| `id` | `String` | Het lidmaatschaps-ID |
| `productId` | `String` | Het product waartoe dit lidmaatschap behoort |
| `planId` | `String` | Compatibiliteitsveld met het variant-ID voor dit lidmaatschap |
| `status` | `Status` | Huidige status van het lidmaatschap |
| `isActive` | `Bool` | Of het lidmaatschap toegang geeft (true voor `active`, `trialing`, `canceling`, `pastDue`, `completed`) |
| `isClaimed` | `Bool` | Of een gebruiker het lidmaatschap heeft geclaimd |
| `createdAt` | `Date` | Wanneer Whop het lidmaatschap heeft aangemaakt |
| `expiresAt` | `Date?` | Wanneer het lidmaatschap verloopt |
| `renewalPeriodEnd` | `Date?` | Einde van de huidige verlengingsperiode |
| `cancelAtPeriodEnd` | `Bool` | Of het lidmaatschap aan het einde van de periode wordt opgezegd |
| `receiptId` | `String?` | De bon-ID voor dit lidmaatschap |

***

### WhopCheckoutError

Fouten die door de SDK worden gegenereerd.

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

| Case | Beschrijving |
| - | - |
| `cancelled` | De gebruiker heeft het checkoutvenster gesloten zonder de aankoop te voltooien |
| `notConfigured` | De SDK is niet geconfigureerd. Roep eerst `Checkout.shared.configure()` aan. |
| `paymentFailed(String)` | De betaling is mislukt. De bijbehorende string bevat de foutmelding. |

***

## Geschiktheid voor `Apple Pay`

> [!WARNING]
>
> **De meeste apps zouden Apple Pay niet moeten gebruiken.** Apple Pay via de WhopCheckout-SDK is
> alleen bedoeld voor apps die fysieke goederen of diensten in de echte wereld verkopen, niet voor digitale
> content, abonnementen op appfuncties of in-app-valuta.

### Richtlijnen voor `App Store`-beoordeling

[App Store Review Guideline 3.1.1](https://developer.apple.com/app-store/review/guidelines/#in-app-purchase) van Apple vereist dat **digitale goederen en diensten** (premiumfuncties, abonnementen, het ontgrendelen van content, virtuele valuta) In-App Purchase (StoreKit) gebruiken. Apple Pay is voor deze transacties uitdrukkelijk verboden.

[Guideline 3.1.3(e)](https://developer.apple.com/app-store/review/guidelines/#multiplatform-services) en de [Apple Pay-richtlijnen](https://developer.apple.com/apple-pay/) staan Apple Pay toe voor de aankoop van **fysieke goederen en diensten in de echte wereld**.

### Apps die in aanmerking komen

Apps die Apple Pay (`Checkout.ApplePayButton`) **mogen** gebruiken:

| Categorie | Voorbeelden |
| - | - |
| E-commerce | Kleding, elektronica, fysieke merchandise |
| Eten en bezorging | Maaltijdbezorging, boodschappenbestellingen |
| Vervoer | Ritdiensten, autoverhuur, parkeren |
| Reizen en horeca | Hotelboekingen, vliegtickets, evenementtickets |
| Professionele diensten | Bijlessen, consultancy, boekingen voor reparaties aan huis |
| Fitness en welzijn | Boekingen voor fysieke lessen, personal training |

Apps die StoreKit (`.storeKit`) of de webcheckout van Whop (`.whop`) **moeten** gebruiken:

| Categorie | Voorbeelden |
| - | - |
| Digitale abonnementen | Premium appfuncties, pro-niveaus |
| Digitale content | E-books, muziek, videostreaming |
| Virtuele goederen | In-app-valuta, cosmetische items, power-ups |
| Online cursussen | Videocursussen, digitale workshops |
| SaaS-functies | Upgrades van cloudopslag, niveaus voor API-toegang |

### Hoe je kiest

```
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)
```

Als je app in aanmerking komt, gebruik dan `Checkout.ApplePayButton`. Als je niet zeker weet of je app in aanmerking komt, kies dan standaard `.whop` (Verenigde Staten) of `.storeKit` (elders). De SDK regelt dit automatisch wanneer je `purchase()` aanroept zonder een methode op te geven.

***

## Vereisten

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


## Related topics

- [iOS Checkout SDK](https://docs.whop.com/nl/developer/guides/ios/overview.md)
- [De Whop iOS-SDK's installeren](https://docs.whop.com/nl/developer/guides/ios/installation.md)
- [CheckoutElement](https://docs.whop.com/nl/elements/latest/checkout/checkout.md)
