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

# Reference til iOS Checkout SDK

> Reference til klasserne, metoderne og typerne i WhopCheckout-iOS-SDK'et.

Denne side dokumenterer alle klasser, metoder, egenskaber og typer, der er tilgængelige i WhopCheckout-SDK'et.

> [!NOTE]
>
> Se [Byg en
> betalingsmur](https://docs.whop.com/da/developer/guides/ios/build-a-paywall.md) eller [Tjek
> rettigheder](https://docs.whop.com/da/developer/guides/ios/check-entitlements.md) for guides.

## Checkout

Hovedklassen til håndtering af køb i appen. SwiftUI's environment-system kan bruge denne `@Observable`-klasse.

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

***

### `shared`

Den delte Checkout-instans. Brug denne singleton til at konfigurere SDK'et og håndtere køb.

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

**Eksempel:**

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

Konfigurerer og initialiserer SDK'et. Kald dette én gang ved app-start.

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

**Parametre:**

| Parameter | Type | Beskrivelse |
| - | - | - |
| `companyId` | `String` | Dit Whop-konto-ID (starter med `biz_`) |
| `apiKey` | `String` | Din API-nøgle. Giv den kun scopet `iap:read` – se [Opret en API-nøgle](https://docs.whop.com/da/developer/guides/ios/installation.md#step-3-create-an-api-key) for at se, hvorfor den er sikker at indlejre i din app. |
| `planMappings` | `[PlanMapping]` | Kompatibilitetsegenskab, der mapper Whop-variant-ID'er til Apple StoreKit-produkt-ID'er. Send et tomt array, hvis du ikke har brug for StoreKit-fallback. |

**Eksempel:**

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

Angiver, om SDK'et er færdig med at initialisere.

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

**Eksempel:**

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

***

### deviceId

Den unikke enhedsidentifikator, som SDK'et administrerer. Bevares på tværs af app-starter ved hjælp af iOS-nøgleringen.

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

***

### appUserId

Den aktuelle brugers ID eller `nil` for en gæst.

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

***

### `plans`

Kompatibilitetsegenskab, der indeholder de tilgængelige abonnementsvarianter for de konfigurerede produkter.

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

**Eksempel:**

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

***

### `memberships`

Array med aktive medlemskaber for den aktuelle bruger eller enhed.

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

***

### `isSubscribed`

Om brugeren har et aktivt medlemskab.

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

**Eksempel:**

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

***

### `supportsExternalPurchases`

Om den aktuelle App Store-region understøtter eksterne køb (uden StoreKit). I øjeblikket `true` for brugere i USA og `false` andre steder.

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

Når `true`, bruger SDK'et som standard Whops webcheckout (lavere gebyrer). Når `false`, bruger det som standard StoreKit.

***

### `refreshPlans()`

Opdaterer de tilgængelige varianter fra serveren.

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

**Returnerer:** De opdaterede varianter med aktuelle priser.

**Kaster:** `WhopCheckoutError`, hvis opdateringen fejler.

Kald dette for at opdatere priser eller tilgængelighed af varianter efter initialisering. Det opdaterer også kompatibilitetsegenskaben `plans` med de seneste data.

**Eksempel:**

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

Tjekker, om brugeren har adgang til et bestemt produkt.

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

**Parametre:**

| Parameter | Type | Beskrivelse |
| - | - | - |
| `productId` | `String` | Det produkt-ID, der skal tjekkes (starter med `prod_`) |

**Returnerer:** `true`, hvis brugeren har et aktivt medlemskab af produktet

**Eksempel:**

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

***

### purchase(\_:method:)

Starter et købsforløb for en variant. Bruger som standard Whops webcheckout i USA (lavere gebyrer) og StoreKit andre steder.

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

**Parametre:**

| Parameter | Type | Beskrivelse |
| - | - | - |
| `whopPlanId` | `String` | Det Whop-variant-ID, der skal købes (beholder præfikset `plan_`) |
| `method` | `PaymentMethod?` | Tilsidesæt betalingsmetoden. Standardværdien afhænger af regionen. |

**Returnerer:** `CheckoutPurchaseResult` med kvitterings-ID og oplysninger om medlemskabet

**Kaster:**

* `WhopCheckoutError.cancelled`, hvis brugeren lukker checkouten
* `WhopCheckoutError.notConfigured`, hvis SDK'et ikke er konfigureret
* `WhopCheckoutError.paymentFailed(String)`, hvis betalingen fejler

**Eksempel:**

```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]
>
> Til Apple Pay skal du bruge [`Checkout.ApplePayButton`](#checkout-applepaybutton) eller
> [`presentApplePay(_:)`](#presentapplepay-_), når din brugerflade udløser Apple Pay
> fra en brugerdefineret interaktion.

***

### logIn(appUserId:)

Logger en bruger ind og gør krav på alle ikke-tilknyttede medlemskaber, der er knyttet til enheden.

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

**Parametre:**

| Parameter | Type | Beskrivelse |
| - | - | - |
| `appUserId` | `String` | Din apps bruger-ID (bør ikke ændres for den samme bruger) |

**Eksempel:**

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

***

### `logOut()`

Logger den aktuelle bruger ud og rydder brugerens medlemskaber fra den lokale tilstand.

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

**Eksempel:**

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

***

### `restorePurchases()`

Gendanner køb fra både StoreKit og Whop.

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

**Returnerer:** `true`, hvis SDK'et fandt et aktivt abonnement

**Eksempel:**

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

***

## Typer

### `CheckoutPurchaseResult`

Resultatet af et vellykket køb.

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

| Egenskab | Type | Beskrivelse |
| - | - | - |
| `receiptId` | `String` | Det unikke kvitterings-ID for dette køb |
| `membership` | `CheckoutMembership?` | Det medlemskab, der blev oprettet ved dette køb |

> [accordion] Hvornår er membership nil?
>
> Egenskaben `membership` afhænger af den anvendte betalingsmetode:
>
> | Betalingsmetode | Region | `membership`-værdi |
> | - | - | - |
> | Whop-webcheckout | USA | Udfyldt med det samme |
> | StoreKit | Uden for USA | `nil` til at begynde med |
>
> **Hvorfor StoreKit-køb returnerer nil:**
> StoreKit-transaktioner behandles asynkront af Apple. Når købet gennemføres, har SDK'et måske endnu ikke synkroniseret Whop-medlemskabet. SDK'et sporer også StoreKit-rettigheder, så `checkout.isSubscribed` returnerer stadig `true`.
>
> **Sådan håndterer du begge tilfælde:**
>
> ```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
> }
> ```
>
> **Vigtigt:** Stol ikke på, at `membership` ikke er nil, for at give adgang. Brug altid `checkout.isSubscribed` eller `checkout.hasAccess(to:)` til at tjekke abonnementsstatus.

***

### `PlanMapping`

En mapping mellem en Whop-variant og et Apple StoreKit-produkt, der bruges under konfigurationen af SDK'et. Den fortæller SDK'et, hvilket Apple-produkt der skal bruges til StoreKit-køb uden for USA.

> [!NOTE]
>
> **PlanMapping vs. CheckoutPlan:** `PlanMapping` er til konfiguration af SDK'et
> (mapping af ID'er). `CheckoutPlan` er det, du viser i din brugerflade (har priser,
> titler osv.). Du opretter `PlanMapping`-objekter i `configure()` og får derefter adgang til
> `CheckoutPlan`-objekter via `checkout.plans`.

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

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

| Egenskab | Type | Beskrivelse |
| - | - | - |
| `whopId` | `String` | Whop-variant-ID'et (f.eks. `plan_xxx`) |
| `appleId` | `String` | Apple-produkt-ID'et fra App Store Connect (f.eks. `com.yourapp.monthly`) |

**Eksempel:**

```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]
>
> Dine Whop-varianter og Apple-produkter bør have matchende priser og
> faktureringsperioder. Se [`PlanMapping`](#planmapping) for detaljer om kompatibilitets-API'et.

***

### `PaymentMethod`

Den betalingsmetode, der skal bruges til et køb.

```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 | Beskrivelse |
| - | - |
| `whop` | Webcheckout via Whop. Gebyrer på 2,7 % + \$0,30 (mod Apples 15-30 %). Tilgængelig i USA. |
| `storeKit` | StoreKit-køb i appen via App Store (gebyrer på 15-30 %). Bruges som fallback uden for USA. |

> [!NOTE]
>
> Apple Pay er ikke inkluderet i `PaymentMethod` – det har sine egne flader:
> [`Checkout.ApplePayButton`](#checkout-applepaybutton) og
> [`presentApplePay(_:)`](#presentapplepay-_).

***

### `Checkout.ApplePayButton`

En færdigbygget SwiftUI-visning, der renderer Apples officielle Apple Pay-knap og håndterer hele købsforløbet. **Du skal bruge denne komponent** (eller `PKPaymentButton` / `PayWithApplePayButton`), når du tilbyder Apple Pay – knapper med brugerdefineret styling er ikke tilladt ifølge Apples Human Interface Guidelines.

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

**Parametre:**

| Parameter | Type | Beskrivelse |
| - | - | - |
| `planId` | `String` | Det Whop-variant-ID, der skal købes |
| `label` | `PayWithApplePayButtonLabel` | Knappens tekststil: `.plain`, `.buy`, `.subscribe`, `.checkout`, `.book`, `.order` osv. |
| `onCompletion` | `(Result) -> Void` | Kaldes ved succes eller fejl. **Kaldes ikke**, når brugeren annullerer. |

**Eksempel:**

```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 er ikke til digitalt indhold.** Brug kun `Checkout.ApplePayButton`,
> hvis din app sælger fysiske varer eller tjenester i den virkelige verden. Apps, der sælger digitalt
> indhold (abonnementer på premiumfunktioner, valuta i appen osv.), skal bruge
> StoreKit. Se afsnittet [Berettigelse til Apple Pay](#apple-pay-eligibility)
> nedenfor.

### `presentApplePay(_:)`

Viser Apple Pay-arket direkte til brugerflader, der starter Apple Pay fra en brugerdefineret interaktion (f.eks. en skub-for-at-betale-kontrol) i stedet for den færdigbyggede knap.

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

Kald det kun som direkte svar på en brugerinteraktion – Apple tillader kun at vise et betalingsark, når brugeren udtrykkeligt har bedt om at betale. Kaster `WhopCheckoutError.cancelled`, når brugeren lukker arket.

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

De samme regler for [berettigelse til Apple Pay](#apple-pay-eligibility) gælder som for `Checkout.ApplePayButton`.

***

### Visningsmodellen `CheckoutPlan`

En abonnementsvariant, der kan købes, og som tilgås via kompatibilitetsegenskaben `checkout.plans`. Brug den til at vise variantoplysninger i din brugerflade og til at foretage køb.

> [!NOTE]
>
> **Kompatibilitetstyper:** `CheckoutPlan` indeholder alle variantoplysninger (priser,
> titler, info om prøveperiode) til din brugerflade. `Plan` er en ID-mapping, der bruges under
> konfigurationen af SDK'et. Du opretter aldrig selv `CheckoutPlan`-objekter – de kommer fra
> `checkout.plans` efter konfigurationen.

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

| Egenskab | Type | Beskrivelse |
| - | - | - |
| `id` | `String` | Variant-ID'et |
| `productId` | `String?` | Det produkt, som denne variant tilhører |
| `title` | `String?` | Variantens visningsnavn |
| `description` | `String?` | Beskrivelsestekst for varianten |
| `planType` | `PlanType` | Om dette er en engangsvariant eller en tilbagevendende variant |
| `billingPeriodDays` | `Int?` | Antal dage i faktureringscyklussen (30 = månedlig, 365 = årlig) |
| `baseCurrency` | `String` | Valutakode (f.eks. `usd`) |
| `initialPrice` | `Double` | Variantens startpris |
| `renewalPrice` | `Double` | Pris for fornyelser |
| `trialPeriodDays` | `Int?` | Antal dage i prøveperioden |
| `renewalPeriod` | `RenewalPeriod?` | Beregnet fornyelsesperiode (`.monthly`, `.yearly` osv.) |
| `whopDisplayPrice` | `String` | Formateret Whop-pris (f.eks. "\$9.99") |
| `appleDisplayPrice` | `String?` | Lokaliseret StoreKit-pris, hvis der findes en variantmapping |

***

### `CheckoutMembership`

Et aktivt abonnementsmedlemskab.

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

| Egenskab | Type | Beskrivelse |
| - | - | - |
| `id` | `String` | Medlemskabets ID |
| `productId` | `String` | Det produkt, som dette medlemskab tilhører |
| `planId` | `String` | Kompatibilitetsfelt, der indeholder variant-ID'et for dette medlemskab |
| `status` | `Status` | Medlemskabets aktuelle status |
| `isActive` | `Bool` | Om medlemskabet giver adgang (true for `active`, `trialing`, `canceling`, `pastDue`, `completed`) |
| `isClaimed` | `Bool` | Om en bruger har gjort krav på medlemskabet |
| `createdAt` | `Date` | Hvornår Whop oprettede medlemskabet |
| `expiresAt` | `Date?` | Hvornår medlemskabet udløber |
| `renewalPeriodEnd` | `Date?` | Slutningen af den aktuelle fornyelsesperiode |
| `cancelAtPeriodEnd` | `Bool` | Om medlemskabet opsiges ved periodens udløb |
| `receiptId` | `String?` | Kvitterings-ID'et for dette medlemskab |

***

### WhopCheckoutError

Fejl, som SDK'et kaster.

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

| Case | Beskrivelse |
| - | - |
| `cancelled` | Brugeren lukkede checkout-arket uden at gennemføre købet |
| `notConfigured` | SDK'et er ikke konfigureret. Kald `Checkout.shared.configure()` først. |
| `paymentFailed(String)` | Betalingen fejlede. Den tilknyttede streng indeholder fejlmeddelelsen. |

***

## Berettigelse til `Apple Pay`

> [!WARNING]
>
> **De fleste apps bør ikke bruge Apple Pay.** Apple Pay via WhopCheckout-SDK'et er
> kun til apps, der sælger fysiske varer eller tjenester i den virkelige verden – ikke digitalt
> indhold, abonnementer på appfunktioner eller valuta i appen.

### Retningslinjer for `App Store`-gennemgang

Apples [App Store Review Guideline 3.1.1](https://developer.apple.com/app-store/review/guidelines/#in-app-purchase) kræver, at **digitale varer og tjenester** (premiumfunktioner, abonnementer, oplåsning af indhold, virtuel valuta) skal bruge In-App Purchase (StoreKit). Apple Pay er udtrykkeligt forbudt til disse transaktioner.

[Guideline 3.1.3(e)](https://developer.apple.com/app-store/review/guidelines/#multiplatform-services) og [Apple Pay-retningslinjerne](https://developer.apple.com/apple-pay/) tillader Apple Pay til køb af **fysiske varer og tjenester i den virkelige verden**.

### Apps, der opfylder kravene

Apps, der **kan** bruge Apple Pay (`Checkout.ApplePayButton`):

| Kategori | Eksempler |
| - | - |
| E-handel | Tøj, elektronik, fysisk merchandise |
| Mad og levering | Levering af måltider, dagligvarebestillinger |
| Transport | Kørselstjenester, biludlejning, parkering |
| Rejser og hotel | Hotelbookinger, flybilletter, billetter til events |
| Professionelle tjenester | Undervisningssessioner, rådgivning, booking af reparationer i hjemmet |
| Fitness og velvære | Booking af hold med fysisk fremmøde, personlig træning |

Apps, der **skal** bruge StoreKit (`.storeKit`) eller Whops webcheckout (`.whop`):

| Kategori | Eksempler |
| - | - |
| Digitale abonnementer | Premiumfunktioner i appen, pro-niveauer |
| Digitalt indhold | E-bøger, musik, videostreaming |
| Virtuelle varer | Valuta i appen, kosmetiske genstande, power-ups |
| Onlinekurser | Videokurser, digitale workshops |
| SaaS-funktioner | Opgraderinger af cloudlagring, adgangsniveauer til API |

### Sådan vælger du

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

Hvis din app opfylder kravene, skal du bruge `Checkout.ApplePayButton`. Hvis du er i tvivl om, hvorvidt din app opfylder kravene, skal du som standard bruge `.whop` (USA) eller `.storeKit` (andre steder). SDK'et håndterer dette automatisk, når du kalder `purchase()` uden at angive en metode.

***

## Krav

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


## Related topics

- [iOS Checkout SDK](https://docs.whop.com/da/developer/guides/ios/overview.md)
- [Installér Whops iOS-SDK'er](https://docs.whop.com/da/developer/guides/ios/installation.md)
- [Checkout](https://docs.whop.com/da/elements/latest/checkout/overview.md)
