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

# Accepter des paiements ponctuels

> Acceptez des paiements ponctuels Apple Pay pour des biens physiques et des services réels dans votre app iOS.

[Accepter des paiements ponctuels sur iOS avec Whop](https://www.youtube.com/embed/K2e_sht1P1I?rel=0)

Utilisez `Checkout.ApplePayButton` pour accepter des paiements ponctuels pour des biens physiques ou des services réels avec Apple Pay. Whop traite les paiements à **2,7 % + 0,30 \$** au lieu des frais d'achat intégré de 15 à 30 % d'Apple.

> [!TIP]
>
> Pour les ventes sur le web, utilisez [les liens de checkout ou l'élément Checkout](https://docs.whop.com/fr/developer/guides/accept-payments.md) pour bénéficier de **plus de 100 moyens de paiement** dans **195 pays**.

> [!WARNING]
>
> **Apple Pay n'est pas destiné au contenu numérique.** N'utilisez `Checkout.ApplePayButton` que si votre app vend des biens physiques (merch, nourriture, matériel) ou des services réels (billets d'événements, livraisons). Les apps qui vendent du contenu numérique (fonctionnalités premium, abonnements, monnaie intégrée, déblocage de contenu) doivent utiliser StoreKit. Consultez la section [Éligibilité à Apple Pay](https://docs.whop.com/fr/developer/guides/ios/checkout-reference.md#apple-pay-eligibility) pour plus de détails.

## Ce que vous allez créer

* Un écran de détail produit avec un bouton Apple Pay natif
* Un parcours d'achat qui gère la réussite, l'échec et l'annulation
* La configuration des variantes dans le tableau de bord Whop pour vos biens physiques

## Prérequis

* [Installer le SDK WhopCheckout](https://docs.whop.com/fr/developer/guides/ios/installation.md)
* Une clé API limitée à `iap:read` : consultez [Créer une clé API](https://docs.whop.com/fr/developer/guides/ios/installation.md#step-3-create-an-api-key)
* Un produit Whop avec une variante ponctuelle (voir l'[étape 5](#step-5-set-up-your-variant))

## Étape 1 : configurer le SDK

Initialisez le SDK au lancement de l'app. Pour des biens physiques ponctuels, vous n'avez pas besoin de la propriété de compatibilité `planMappings` : elle ne sert qu'au repli sur StoreKit pour les abonnements.

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

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

Consultez le [guide d'installation](https://docs.whop.com/fr/developer/guides/ios/installation.md) pour la configuration complète et les remarques de sécurité concernant la clé API.

## Étape 2 : ajouter le bouton `Apple Pay`

Placez `Checkout.ApplePayButton` dans la vue de votre produit. Le composant affiche le bouton Apple Pay officiel d'Apple, conforme aux Human Interface Guidelines : vous ne pouvez pas le remplacer par un bouton au style personnalisé.

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

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

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

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

Lorsque l'utilisateur appuie dessus, la feuille Apple Pay native s'affiche. Face ID ou un double-clic confirme, et le paiement transite par Whop.

> [!NOTE]
>
> `onCompletion` **n'est pas appelé** lorsque l'utilisateur annule : la feuille se ferme simplement. Aucun nettoyage n'est nécessaire.

## Étape 3 : choisir un libellé de bouton

Le paramètre `label` contrôle le texte du bouton. Choisissez celui qui correspond à l'action :

| Libellé | Texte du bouton | Utilisation |
| - | - | - |
| `.buy` | Buy with Apple Pay | Merchandising ponctuel et biens physiques |
| `.checkout` | Check out with… | Parcours de checkout de type panier |
| `.order` | Order with Apple Pay | Nourriture, livraisons, articles sur commande |
| `.book` | Book with Apple Pay | Réservations, rendez-vous, événements |
| `.continue` | Continue with… | Parcours en plusieurs étapes où ce n'est pas la dernière |
| `.plain` | (logo Apple Pay) | Solution de repli quand aucun verbe ne convient |

La liste complète provient de `PayWithApplePayButtonLabel` d'Apple : consultez la [documentation d'Apple](https://developer.apple.com/documentation/passkit/paywithapplepaybuttonlabel) pour connaître toutes les options.

## Étape 4 : gérer le résultat de l'achat

`onCompletion` reçoit un `Result<CheckoutPurchaseResult, Error>`. En cas de réussite, vous récupérez :

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

Utilisez-le pour afficher un écran de confirmation, lancer l'expédition ou conserver le reçu dans vos propres registres.

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

## Étape 5 : configurer votre variante

Chaque article achetable nécessite une variante dans votre tableau de bord Whop :

**1. Créer une variante**

Accédez à votre [tableau de bord](https://whop.com/dashboard) > Products > sélectionnez votre produit > **Variants** > **Create variant**.

**2. La définir comme ponctuelle**

Choisissez **One-time payment** et définissez le prix.

**3. (Facultatif) Définir des limites de stock**

Pour les éditions limitées, définissez un plafond de stock. Le checkout l'applique automatiquement : lorsque le stock est épuisé, les achats s'arrêtent.

**4. Copier l'ID de la variante**

L'ID conserve le préfixe `plan_`. Transmettez-le via le paramètre de compatibilité `Checkout.ApplePayButton(planId:)`.

## Gérer le traitement des commandes avec les webhooks

Pour les biens physiques, vous aurez besoin d'un webhook côté serveur pour déclencher l'expédition après un achat réussi. Écoutez l'événement `payment.succeeded` :

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

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

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

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

> [!NOTE]
>
> Le callback `onCompletion` côté client confirme le paiement à l'utilisateur, mais c'est votre **serveur** qui doit traiter la commande via les webhooks : ne vous fiez pas uniquement au client. Consultez le [guide des webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) complet pour la configuration.

## Exemple complet

Une vue minimale de détail d'article avec sélection de taille et Apple Pay :

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

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

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

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

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

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

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

## Prochaines étapes

> [card] [Webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Gérez les événements de paiement et déclenchez le traitement des commandes

> [card] [Éligibilité à Apple Pay](https://docs.whop.com/fr/developer/guides/ios/checkout-reference.md#apple-pay-eligibility)
>
> Vérifiez que votre app est éligible selon les App Store Review Guidelines

> [card] [Créer un paywall](https://docs.whop.com/fr/developer/guides/ios/build-a-paywall.md)
>
> Vendez des abonnements plutôt que des achats ponctuels

> [card] [Référence de l'API](https://docs.whop.com/fr/developer/guides/ios/checkout-reference.md)
>
> Documentation complète du SDK


## Related topics

- [SDK iOS Checkout](https://docs.whop.com/fr/developer/guides/ios/overview.md)
- [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
- [Enregistrer des moyens de paiement](https://docs.whop.com/fr/developer/guides/save-payment-methods.md)
