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

# Référence du SDK iOS Checkout

> Référence des classes, méthodes et types du SDK iOS WhopCheckout.

Cette page documente toutes les classes, méthodes, propriétés et tous les types disponibles dans le SDK WhopCheckout.

> [!NOTE]
>
> Pour les guides, consultez [Créer un
> paywall](https://docs.whop.com/fr/developer/guides/ios/build-a-paywall.md) ou [Vérifier les droits
> d'accès](https://docs.whop.com/fr/developer/guides/ios/check-entitlements.md).

## Checkout

La classe principale de gestion des achats intégrés. Le système d'environnement de SwiftUI peut utiliser cette classe `@Observable`.

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

***

### `shared`

L'instance Checkout partagée. Utilisez ce singleton pour configurer le SDK et gérer les achats.

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

**Exemple :**

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

Configure et initialise le SDK. Appelez-la une seule fois au démarrage de l'app.

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

**Paramètres :**

| Paramètre | Type | Description |
| - | - | - |
| `companyId` | `String` | L'ID de votre compte Whop (commence par `biz_`) |
| `apiKey` | `String` | Votre clé API. Ne lui accordez que le scope `iap:read` : consultez [Créer une clé API](https://docs.whop.com/fr/developer/guides/ios/installation.md#step-3-create-an-api-key) pour comprendre pourquoi elle peut être intégrée sans risque dans votre app. |
| `planMappings` | `[PlanMapping]` | Propriété de compatibilité qui associe les ID de variantes Whop aux ID de produits Apple StoreKit. Transmettez un tableau vide si vous n'avez pas besoin du repli sur StoreKit. |

**Exemple :**

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

Indique si le SDK a terminé son initialisation.

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

**Exemple :**

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

***

### deviceId

L'identifiant unique de l'appareil géré par le SDK. Il persiste entre les lancements de l'app grâce au trousseau iOS (Keychain).

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

***

### appUserId

L'ID de l'utilisateur actuel, ou `nil` pour un invité.

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

***

### `plans`

Propriété de compatibilité contenant les variantes d'abonnement disponibles pour les produits configurés.

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

**Exemple :**

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

***

### `memberships`

Tableau des adhésions actives de l'utilisateur ou de l'appareil actuel.

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

***

### `isSubscribed`

Indique si l'utilisateur dispose d'au moins une adhésion active.

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

**Exemple :**

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

***

### `supportsExternalPurchases`

Indique si la région App Store actuelle prend en charge les achats externes (hors StoreKit). Actuellement `true` pour les utilisateurs aux États-Unis et `false` ailleurs.

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

Lorsque la valeur est `true`, le SDK utilise par défaut le checkout web de Whop (frais réduits). Lorsqu'elle est `false`, il utilise par défaut StoreKit.

***

### `refreshPlans()`

Actualise les variantes disponibles depuis le serveur.

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

**Renvoie :** les variantes actualisées avec leurs prix actuels.

**Lève :** `WhopCheckoutError` si l'actualisation échoue.

Appelez cette méthode pour mettre à jour les prix ou la disponibilité des variantes après l'initialisation. Elle met aussi à jour la propriété de compatibilité `plans` avec les dernières données.

**Exemple :**

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

Vérifie si l'utilisateur a accès à un produit spécifique.

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

**Paramètres :**

| Paramètre | Type | Description |
| - | - | - |
| `productId` | `String` | L'ID du produit à vérifier (commence par `prod_`) |

**Renvoie :** `true` si l'utilisateur dispose d'une adhésion active pour le produit

**Exemple :**

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

***

### purchase(\_:method:)

Lance un parcours d'achat pour une variante. Par défaut, utilise le checkout web de Whop aux États-Unis (frais réduits) et StoreKit ailleurs.

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

**Paramètres :**

| Paramètre | Type | Description |
| - | - | - |
| `whopPlanId` | `String` | L'ID de la variante Whop à acheter (conserve le préfixe `plan_`) |
| `method` | `PaymentMethod?` | Remplace le moyen de paiement. Par défaut, il dépend de la région. |

**Renvoie :** `CheckoutPurchaseResult` contenant l'ID du reçu et les informations d'adhésion

**Lève :**

* `WhopCheckoutError.cancelled` si l'utilisateur ferme le checkout
* `WhopCheckoutError.notConfigured` si le SDK n'est pas configuré
* `WhopCheckoutError.paymentFailed(String)` si le paiement échoue

**Exemple :**

```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]
>
> Pour Apple Pay, utilisez [`Checkout.ApplePayButton`](#checkout-applepaybutton), ou
> [`presentApplePay(_:)`](#presentapplepay-_) lorsque votre interface déclenche Apple Pay
> à partir d'une interaction personnalisée.

***

### logIn(appUserId:)

Connecte un utilisateur et revendique les adhésions non revendiquées associées à l'appareil.

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

**Paramètres :**

| Paramètre | Type | Description |
| - | - | - |
| `appUserId` | `String` | L'ID utilisateur de votre app (ne doit pas changer pour un même utilisateur) |

**Exemple :**

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

***

### `logOut()`

Déconnecte l'utilisateur actuel et efface ses adhésions de l'état local.

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

**Exemple :**

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

***

### `restorePurchases()`

Restaure les achats depuis StoreKit et Whop.

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

**Renvoie :** `true` si le SDK a trouvé un abonnement actif

**Exemple :**

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

***

## Types

### `CheckoutPurchaseResult`

Le résultat d'un achat réussi.

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

| Propriété | Type | Description |
| - | - | - |
| `receiptId` | `String` | L'ID de reçu unique pour cet achat |
| `membership` | `CheckoutMembership?` | L'adhésion créée par cet achat |

> [accordion] Quand membership vaut-il nil ?
>
> La propriété `membership` dépend du moyen de paiement utilisé :
>
> | Moyen de paiement | Région | Valeur de `membership` |
> | - | - | - |
> | Checkout web de Whop | États-Unis | Renseignée immédiatement |
> | StoreKit | Hors États-Unis | `nil` initialement |
>
> **Pourquoi les achats StoreKit renvoient nil :**
> Les transactions StoreKit sont traitées de manière asynchrone par Apple. Lorsque l'achat se termine, le SDK n'a peut-être pas encore synchronisé l'adhésion Whop. Le SDK suit aussi les droits StoreKit : `checkout.isSubscribed` renverra donc tout de même `true`.
>
> **Comment gérer les deux cas :**
>
> ```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
> }
> ```
>
> **Point clé :** ne vous fiez pas à une valeur non nil de `membership` pour accorder l'accès. Utilisez toujours `checkout.isSubscribed` ou `checkout.hasAccess(to:)` pour vérifier le statut d'abonnement.

***

### `PlanMapping`

Une correspondance entre une variante Whop et un produit Apple StoreKit, utilisée lors de la configuration du SDK. Elle indique au SDK quel produit Apple utiliser pour les achats StoreKit en dehors des États-Unis.

> [!NOTE]
>
> **PlanMapping vs CheckoutPlan :** `PlanMapping` sert à la configuration du SDK
> (correspondance des ID). `CheckoutPlan` est ce que vous affichez dans votre interface (prix,
> titres, etc.). Vous créez des objets `PlanMapping` dans `configure()`, puis vous accédez
> aux objets `CheckoutPlan` via `checkout.plans`.

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

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

| Propriété | Type | Description |
| - | - | - |
| `whopId` | `String` | L'ID de la variante Whop (par ex. `plan_xxx`) |
| `appleId` | `String` | L'ID du produit Apple issu d'App Store Connect (par ex. `com.yourapp.monthly`) |

**Exemple :**

```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]
>
> Vos variantes Whop et vos produits Apple doivent avoir des prix et des périodes de
> facturation correspondants. Consultez [`PlanMapping`](#planmapping) pour les détails de l'API de compatibilité.

***

### `PaymentMethod`

Le moyen de paiement à utiliser pour un achat.

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

| Cas | Description |
| - | - |
| `whop` | Checkout web via Whop. Frais de 2,7 % + 0,30 \$ (contre 15 à 30 % chez Apple). Disponible aux États-Unis. |
| `storeKit` | Achat intégré StoreKit via l'App Store (frais de 15 à 30 %). Utilisé comme solution de repli en dehors des États-Unis. |

> [!NOTE]
>
> Apple Pay n'est pas inclus dans `PaymentMethod` : il dispose de ses propres interfaces,
> [`Checkout.ApplePayButton`](#checkout-applepaybutton) et
> [`presentApplePay(_:)`](#presentapplepay-_).

***

### `Checkout.ApplePayButton`

Une vue SwiftUI prête à l'emploi qui affiche le bouton Apple Pay officiel d'Apple et gère l'ensemble du parcours d'achat. **Vous devez utiliser ce composant** (ou `PKPaymentButton` / `PayWithApplePayButton`) lorsque vous proposez Apple Pay : les Human Interface Guidelines d'Apple n'autorisent pas les boutons au style personnalisé.

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

**Paramètres :**

| Paramètre | Type | Description |
| - | - | - |
| `planId` | `String` | L'ID de la variante Whop à acheter |
| `label` | `PayWithApplePayButtonLabel` | Style du libellé du bouton : `.plain`, `.buy`, `.subscribe`, `.checkout`, `.book`, `.order`, etc. |
| `onCompletion` | `(Result) -> Void` | Appelé en cas de réussite ou d'échec. **N'est pas appelé** lorsque l'utilisateur annule. |

**Exemple :**

```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 n'est pas destiné au contenu numérique.** N'utilisez `Checkout.ApplePayButton`
> que si votre app vend des biens physiques ou des services réels. Les apps qui vendent du
> contenu numérique (abonnements à des fonctionnalités premium, monnaie intégrée, etc.) doivent utiliser
> StoreKit. Consultez la section [Éligibilité à Apple Pay](#apple-pay-eligibility)
> ci-dessous.

### `presentApplePay(_:)`

Présente directement la feuille Apple Pay, pour les interfaces qui déclenchent Apple Pay à partir d'une interaction personnalisée (par exemple un contrôle « glisser pour payer ») plutôt qu'avec le bouton prêt à l'emploi.

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

Appelez-la uniquement en réponse directe à une interaction de l'utilisateur : Apple n'autorise la présentation d'une feuille de paiement que lorsque l'utilisateur a explicitement demandé à payer. Lève `WhopCheckoutError.cancelled` lorsque l'utilisateur ferme la feuille.

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

Les mêmes règles d'[éligibilité à Apple Pay](#apple-pay-eligibility) que pour `Checkout.ApplePayButton` s'appliquent.

***

### Modèle d'affichage `CheckoutPlan`

Une variante d'abonnement disponible à l'achat, accessible via la propriété de compatibilité `checkout.plans`. Utilisez-la pour afficher les informations de variante dans votre interface et pour effectuer des achats.

> [!NOTE]
>
> **Types de compatibilité :** `CheckoutPlan` contient tous les détails de la variante (prix,
> titres, informations d'essai) pour votre interface. `Plan` est une correspondance d'ID utilisée lors de
> la configuration du SDK. Vous ne créez jamais d'objets `CheckoutPlan` : ils proviennent de
> `checkout.plans` après la configuration.

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

| Propriété | Type | Description |
| - | - | - |
| `id` | `String` | L'ID de la variante |
| `productId` | `String?` | Le produit auquel appartient cette variante |
| `title` | `String?` | Nom d'affichage de la variante |
| `description` | `String?` | Texte de description de la variante |
| `planType` | `PlanType` | Indique s'il s'agit d'une variante ponctuelle ou récurrente |
| `billingPeriodDays` | `Int?` | Nombre de jours du cycle de facturation (30 = mensuel, 365 = annuel) |
| `baseCurrency` | `String` | Code de devise (par ex. `usd`) |
| `initialPrice` | `Double` | Prix initial de la variante |
| `renewalPrice` | `Double` | Prix des renouvellements |
| `trialPeriodDays` | `Int?` | Nombre de jours de la période d'essai |
| `renewalPeriod` | `RenewalPeriod?` | Période de renouvellement calculée (`.monthly`, `.yearly`, etc.) |
| `whopDisplayPrice` | `String` | Prix Whop formaté (par ex. "\$9.99") |
| `appleDisplayPrice` | `String?` | Prix StoreKit localisé, si une correspondance de variante existe |

***

### `CheckoutMembership`

Une adhésion d'abonnement active.

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

| Propriété | Type | Description |
| - | - | - |
| `id` | `String` | L'ID de l'adhésion |
| `productId` | `String` | Le produit auquel appartient cette adhésion |
| `planId` | `String` | Champ de compatibilité contenant l'ID de la variante de cette adhésion |
| `status` | `Status` | Statut actuel de l'adhésion |
| `isActive` | `Bool` | Indique si l'adhésion donne accès (true pour `active`, `trialing`, `canceling`, `pastDue`, `completed`) |
| `isClaimed` | `Bool` | Indique si un utilisateur a revendiqué l'adhésion |
| `createdAt` | `Date` | Date de création de l'adhésion par Whop |
| `expiresAt` | `Date?` | Date d'expiration de l'adhésion |
| `renewalPeriodEnd` | `Date?` | Fin de la période de renouvellement actuelle |
| `cancelAtPeriodEnd` | `Bool` | Indique si l'adhésion sera annulée à la fin de la période |
| `receiptId` | `String?` | L'ID du reçu de cette adhésion |

***

### WhopCheckoutError

Erreurs levées par le SDK.

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

| Cas | Description |
| - | - |
| `cancelled` | L'utilisateur a fermé la feuille de checkout sans finaliser l'achat |
| `notConfigured` | Le SDK n'est pas configuré. Appelez d'abord `Checkout.shared.configure()`. |
| `paymentFailed(String)` | Le paiement a échoué. La chaîne associée contient le message d'erreur. |

***

## Éligibilité à `Apple Pay`

> [!WARNING]
>
> **La plupart des apps ne devraient pas utiliser Apple Pay.** Apple Pay via le SDK WhopCheckout est
> réservé aux apps qui vendent des biens physiques ou des services réels, et non du contenu
> numérique, des abonnements à des fonctionnalités d'app ou une monnaie intégrée.

### Directives de validation de l'`App Store`

La [directive 3.1.1 de l'App Store Review](https://developer.apple.com/app-store/review/guidelines/#in-app-purchase) d'Apple exige que les **biens et services numériques** (fonctionnalités premium, abonnements, déblocage de contenu, monnaie virtuelle) utilisent l'achat intégré (StoreKit). Apple Pay est explicitement interdit pour ces transactions.

La [directive 3.1.3(e)](https://developer.apple.com/app-store/review/guidelines/#multiplatform-services) et les [directives Apple Pay](https://developer.apple.com/apple-pay/) autorisent Apple Pay pour l'achat de **biens physiques et de services réels**.

### Apps éligibles

Apps qui **peuvent** utiliser Apple Pay (`Checkout.ApplePayButton`) :

| Catégorie | Exemples |
| - | - |
| E-commerce | Vêtements, électronique, marchandises physiques |
| Restauration et livraison | Livraison de repas, commandes d'épicerie |
| Transport | VTC, location de voitures, stationnement |
| Voyage et hôtellerie | Réservations d'hôtel, billets d'avion, billets d'événements |
| Services professionnels | Cours particuliers, conseil, réservations de dépannage à domicile |
| Fitness et bien-être | Réservations de cours en présentiel, séances de coaching personnel |

Apps qui **doivent** utiliser StoreKit (`.storeKit`) ou le checkout web de Whop (`.whop`) :

| Catégorie | Exemples |
| - | - |
| Abonnements numériques | Fonctionnalités premium d'app, offres pro |
| Contenu numérique | Livres numériques, musique, streaming vidéo |
| Biens virtuels | Monnaie intégrée, objets cosmétiques, bonus |
| Cours en ligne | Cours vidéo, ateliers numériques |
| Fonctionnalités SaaS | Extensions de stockage cloud, niveaux d'accès à une API |

### Comment choisir

```
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 votre app est éligible, utilisez `Checkout.ApplePayButton`. Si vous n'êtes pas sûr que votre app soit éligible, utilisez par défaut `.whop` (États-Unis) ou `.storeKit` (ailleurs). Le SDK gère cela automatiquement lorsque vous appelez `purchase()` sans préciser de méthode.

***

## Prérequis

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


## Related topics

- [SDK iOS Checkout](https://docs.whop.com/fr/developer/guides/ios/overview.md)
- [Installer les SDK iOS de Whop](https://docs.whop.com/fr/developer/guides/ios/installation.md)
- [Créer un paywall iOS](https://docs.whop.com/fr/developer/guides/ios/build-a-paywall.md)
