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

# Aan de slag met Elements

> Installeer Whop Elements en mount je eerste element in React, JavaScript, Swift of React Native.

> [!NOTE]
>
> Deze pagina documenteert `@whop/elements@1.10.0` en `@whop/elements-react@1.10.0`.

Whop Elements zijn gehoste UI-componenten met aanpasbare thema's die je in je eigen site insluit. Elk element wordt weergegeven in een geïsoleerd frame dat vanaf het CDN van Whop wordt geleverd. Je installeert een dun, volledig getypeerd pakket en de elementcode blijft vanzelf up-to-date.

Whop Elements zijn UI-componenten met aanpasbare thema's die je in je iOS-app kunt importeren. Ze worden geleverd als één Swift SPM-pakket. Elk component is een gewone SwiftUI-view die zijn eigen gegevens ophaalt en zijn eigen status beheert, zodat een saldoscherm uit een paar views in een `VStack` bestaat in plaats van een netwerklaag en een viewmodel. Voeg het pakket toe, vertel de SDK hoe die een toegangstoken ophaalt, en plaats de elementen in je viewhiërarchie.

Whop Elements zijn UI-componenten met aanpasbare thema's die je in een React Native-app kunt plaatsen. Het zijn echte React Native-componenten, geen webviews: de tegels voor betaalmethoden, het adresformulier en de kaartvelden zijn allemaal native invoer, en Apple Pay en Google Pay openen de eigen sheet van het platform. Installeer het pakket, vertel de SDK hoe die een toegangstoken ophaalt, en mount de elementen.

## Installatie

Voeg het pakket toe aan je `Package.swift` (of **File → Add Package Dependencies** in Xcode):

Installeer de SDK:

```bash React theme={null}
npm install @whop/elements-react @whop/elements
```

```bash React Native theme={null}
npm install @whop/elements-react-native
```

```bash JavaScript theme={null}
npm install @whop/elements
```

```swift Swift theme={null}
dependencies: [
    .package(url: "https://github.com/whopio/whopsdk-elements-swift.git", from: "0.1.12")
]
```

## Vereisten

| | |
| - | - |
| React | `^17.0.0 \|\| ^18.0.0 \|\| ^19.0.0`, voor `@whop/elements-react`. |
| Content Security Policy | Je beleid heeft elke bron nodig uit de [Content Security Policy-tabel](#content-security-policy) hieronder. |

### Content Security Policy

| Vereiste | Directive | Productiebron | Sandboxbron |
| - | - | - | - |
| Elements-frames | `frame-src` | `https://cdn.whop.com` | Hetzelfde |
| De scripttag, als je die laadt | `script-src` | `https://cdn.whop.com` | Hetzelfde |
| De Whop API | `connect-src` | `https://api.whop.com` | `https://sandbox-api.whop.com` |
| De Whop-pixel | `script-src` | `https://t.whop.tw` | Geen |
| De Whop-pixel | `connect-src` | `https://t.whop.tw` | Geen |
| Apple Pay, Google Pay en PayPal | `frame-src` | `https://checkout.paypal.com` `https://assets.braintreegateway.com` `https://www.paypal.com` | `https://checkout.paypal.com` `https://assets.braintreegateway.com` `https://www.sandbox.paypal.com` |
| Apple Pay, Google Pay en PayPal | `script-src` | `https://pay.google.com` `https://applepay.cdn-apple.com` `https://js.braintreegateway.com` `https://assets.braintreegateway.com` `https://www.paypal.com` `https://c.paypal.com` | `https://pay.google.com` `https://applepay.cdn-apple.com` `https://js.braintreegateway.com` `https://assets.braintreegateway.com` `https://www.sandbox.paypal.com` `https://c.paypal.com` |
| Apple Pay, Google Pay en PayPal | `connect-src` | `https://pay.google.com` `https://google.com` `https://account.google.com` `https://www.google.com` `https://api.basistheory.com` `https://payments.braintree-api.com` `https://api.braintreegateway.com` `https://api-m.paypal.com` `https://www.paypal.com` | `https://pay.google.com` `https://google.com` `https://account.google.com` `https://www.google.com` `https://api.basistheory.com` `https://payments.sandbox.braintree-api.com` `https://api.sandbox.braintreegateway.com` `https://api-m.sandbox.paypal.com` `https://www.sandbox.paypal.com` |
| Apple Pay, Google Pay en PayPal | `img-src` | `https://www.paypalobjects.com` | Hetzelfde |
| Plaid-bankrekeningkoppeling | `frame-src` | `https://cdn.plaid.com` | Hetzelfde |
| Plaid-bankrekeningkoppeling | `script-src` | `https://cdn.plaid.com` | Hetzelfde |
| Plaid-bankrekeningkoppeling | `connect-src` | `https://production.plaid.com` | `https://sandbox.plaid.com` |

`contentSecurityPolicy()` uit `@whop/elements` retourneert elke bron in deze tabel, voor de omgeving die je meegeeft. De rijen voor werk aan de paginazijde worden op je pagina uitgevoerd, niet in een frame. De scripts die elementen laden voor Apple Pay, Google Pay en PayPal en voor Plaid-bankrekeningkoppeling komen van andere bedrijven en kunnen resources laden die buiten deze rijen vallen. Raadpleeg ook de Content Security Policy-richtlijnen van elke provider.

> [!WARNING]
>
> Elementen worden weergegeven in frames die worden geleverd vanaf `cdn.whop.com`. Een deel van hun werk wordt op je pagina uitgevoerd en roept vandaaruit `api.whop.com` aan, zoals Apple Pay, Google Pay en PayPal en Plaid-bankrekeningkoppeling. Als je CSP een van beide origins blokkeert, krijg je lege ruimte in plaats van het element of een mislukt verzoek, en de fout verschijnt alleen in de browserconsole.

> [!NOTE]
>
> Een modaal element dimt je pagina erachter met een inline style. Een `style-src` die geen inline styles toestaat, laat de pagina ongedimd, maar de modal werkt nog steeds.

## Voordat je begint

Je hebt twee dingen nodig:

1. **Een `accountId`.** Een account-ID, met prefix `biz_`, of een gebruikers-ID, met prefix `user_`, voor de eigen gegevens van de gebruiker. Betaaloppervlakken accepteren in plaats daarvan een abonnement of bedrag, en elke elementpagina vermeldt wat die nodig heeft.
2. **Een server-endpoint dat een toegangstoken aanmaakt**, met een scope voor de elementen die je mount.

> [!WARNING]
>
> Zet nooit een Whop API-sleutel in browsercode. Die maakt tokens aan, dus iedereen die de ontwikkelaarstools van de browser opent, kan het account lezen. Maak het token aan op je server en verstuur alleen het token.

Je server roept [Create Access Token](https://docs.whop.com/nl/api-reference/access-tokens/create-access-token.md) aan met het account en de scopes die de elementen nodig hebben:

```http theme={null}
POST https://api.whop.com/api/v1/access_tokens
Authorization: Bearer <api_key>
Content-Type: application/json

{ "company_id": "biz_xxxxxxxx", "scoped_actions": ["company:balance:read"] }
```

## Vereisten

| | |
| - | - |
| Platform | iOS 18.0+ |
| Toolchain | Swift 6.0 |
| Installatie | Swift Package Manager |

## Voordat je begint

Je hebt twee dingen nodig:

1. **Een `accountId`.** Een account-ID, met prefix `biz_`, of een gebruikers-ID, met prefix `user_`, voor het eigen saldo van de gebruiker.
2. **Een server-endpoint dat een toegangstoken aanmaakt** voor het account. Lever nooit een Whop API-sleutel mee in de app. Die maakt tokens aan, dus iedereen die de sleutel eruit haalt, kan het account lezen. Maak het token aan op je server en retourneer alleen dat.

Een `user_…`-tag leest de eigen gegevens van de kijker, dus die gebruikt viewer-OAuth (`WhopSDK.configureWithOAuth`) in plaats van een token. Dat geldt ook voor de chatviews.

Je server roept [Create Access Token](https://docs.whop.com/nl/api-reference/access-tokens/create-access-token.md) aan met het account en de scope die de elementen nodig hebben:

```http theme={null}
POST https://api.whop.com/api/v1/access_tokens
Authorization: Bearer <api_key>
Content-Type: application/json

{ "company_id": "biz_xxxxxxxx", "scoped_actions": ["company:balance:read"] }
```

## Vereisten

| | |
| - | - |
| React Native | `0.87+` met Swift Package Manager, `0.86+` met CocoaPods. New Architecture (Fabric) ingeschakeld |
| React | `19.2.3+` |
| iOS | 15.1+ |
| Android | `minSdk 24`, `compileSdk 37` |

> [!NOTE]
>
> **Beide iOS-dependencymanagers werken.** Het pakket bevat zowel een `ios/Package.swift` als een podspec, en de toolchain kiest er een. De Swift Package Manager-autolinker van React Native geeft de voorkeur aan `Package.swift`, dus een app die al SPM gebruikt, wordt niet beïnvloed door de podspec. Een app met CocoaPods, wat momenteel voor elke Expo-app geldt, koppelt via de podspec en heeft verder niets nodig. De minimale React Native-versie is hoger met SPM omdat `Package.swift` twee header-only XCFrameworks koppelt die voor het eerst in 0.87 zijn uitgebracht.

> [!NOTE]
>
> Native code is Swift en Kotlin, gegenereerd via React Native Codegen: niets hier vraagt je om Objective-C of Java handmatig te bewerken, en er zijn geen native peer-dependencies om te installeren.

## Voordat je begint

Je hebt twee dingen nodig:

1. **Een `accountId`.** Een bedrijfs-ID, met prefix `biz_`.
2. **Een server-endpoint dat een toegangstoken aanmaakt** voor dat account. Lever nooit een Whop API-sleutel mee in de app: die maakt tokens aan, dus iedereen die de sleutel eruit haalt, kan namens het account handelen. Maak het token aan op je server en retourneer alleen dat.

Je server roept [Create Access Token](https://docs.whop.com/nl/api-reference/access-tokens/create-access-token.md) aan en geeft het resultaat terug aan `getToken`.

## Je eerste element mounten

Een volledige app. `configure` wordt eenmaal bij het opstarten uitgevoerd, en de elementen tonen een spinner totdat het klaar is, dus niets loopt ervoor uit:

Een volledige checkout. `<WhopElements>` bevat de tokenresolver, `<Payments>` bevat de afschrijving, en de elementen daartussen verzamelen de gegevens:

```tsx React theme={null}
import { WhopElements, Payments, PaymentElement, AddressElement, CardElement, EmailElement, TaxIdElement, BrandingElement } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

function Example() {
  return (
    <WhopElements elements={loadWhop()}>
      <Payments /* options */>
        <PaymentElement />
        <AddressElement />
        <CardElement />
        <EmailElement />
        <TaxIdElement />
        <BrandingElement />
      </Payments>
    </WhopElements>
  );
}
```

```tsx React Native theme={null}
import { useRef, useState } from 'react';
import { Button, ScrollView } from 'react-native';
import {
  AddressElement,
  BrandingElement,
  EmailElement,
  PaymentElement,
  Payments,
  WhopElements,
  type PaymentsHandle,
} from '@whop/elements-react-native';

export function Checkout() {
  const payments = useRef<PaymentsHandle | null>(null);
  const [ready, setReady] = useState(false);

  return (
    // Called again before every request, so fetch rather than cache.
    <WhopElements getToken={() => myBackend.whopAccessToken()}>
      <Payments ref={payments} accountId="biz_xxxxxxxx" plan="plan_xxxxxxxx">
        <ScrollView>
          <EmailElement />
          <AddressElement />
          <PaymentElement onChange={(p) => setReady(p.complete)} />
          <BrandingElement />
        </ScrollView>
        <Button
          title="Pay"
          disabled={!ready}
          onPress={async () => {
            const token = await payments.current!.createConfirmationToken();
            // Confirm server-side, then hand the payment's client_secret back:
            // await payments.current!.handleNextAction({ clientSecret });
            console.log(token.confirmationToken);
          }}
        />
      </Payments>
    </WhopElements>
  );
}
```

```html JavaScript theme={null}
<script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
<script type="module">
  const payments = window.WhopElements().payments.create({ /* options */ });
  payments.create('payment').mount('#payments-payment');
  payments.create('address').mount('#payments-address');
  payments.create('card').mount('#payments-card');
  payments.create('email').mount('#payments-email');
  payments.create('taxId').mount('#payments-taxId');
  payments.create('branding').mount('#payments-branding');
</script>
```

```swift Swift theme={null}
import SwiftUI
import WhopElements

/// The SDK calls this again before the token expires, so fetch rather than cache.
final class WalletTokenProvider: WhopTokenProvider {
    func getToken() async -> WhopTokenResponse {
        WhopTokenResponse(accessToken: await myBackend.whopAccessToken())
    }
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            WalletScreen()
                .task { await WhopSDK.configure(tokenProvider: WalletTokenProvider()) }
        }
    }
}

struct WalletScreen: View {
    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                BalanceElement(accountId: "biz_xxxxxxxx")
                ListElement(accountId: "biz_xxxxxxxx")
            }
            .padding()
        }
    }
}
```

Gebruik je liever npm dan de scripttag? `loadWhop()` injecteert hetzelfde gehoste script en levert de globale constructor op:

```ts theme={null}
import { loadWhop } from "@whop/elements";

const whop = (await loadWhop())({ locale: "en" });
const payments = whop.payments.create({ /* options */ });
```

## Authenticatie

Geef een `accessToken` mee wanneer je de handle aanmaakt. **Gebruik één token voor de hele handle, niet één per element.** De handle stuurt dat token naar elk element eronder, dus vraag alle scopes die je nodig hebt aan voor dat ene token. Elke elementpagina vermeldt de scopes die het leest.

```tsx React theme={null}
<Ads accountId="biz_xxxxxxxx" accessToken={token}>
  {/* elements */}
</Ads>
```

```ts JavaScript theme={null}
const ads = whop.ads.create({ accountId: "biz_xxxxxxxx", accessToken });
```

Het token is een waarde die je instelt, geen callback die de SDK aanroept. Stel een nieuw token in voordat het verloopt:

```ts theme={null}
ads.update({ accessToken: await createAccessToken() });
```

> [!NOTE]
>
> Als je `accessToken` weglaat, gebruiken verzoeken in plaats daarvan de sessiecookie van de kijker. Dit werkt **alleen op whop.com**. De API stuurt geen `Access-Control-Allow-Credentials` bij cross-origin preflights, dus een pagina op je eigen domein heeft geen sessie om op terug te vallen en moet een token meegeven.

## Globale configuratie

Alles wat je bij de constructie meegeeft, geldt voor elke elementgroep die vanuit die instantie wordt aangemaakt (de eigen opties van een handle kunnen dit per groep overschrijven):

**appearance** `Appearance`

Visuele aanpassing voor elk element — `theme` (licht/donker + paletten), `variables` (CSS custom properties) en `classes` (stijldeclaraties per onderdeel). Het kleurenschema wordt toegepast vóór de eerste weergave van een element, zodat donkere pagina's nooit licht oplichten. Zie [Appearance](https://docs.whop.com/nl/elements/latest/appearance.md).

**locale** `string`

Taalinstelling voor de UI-tekst van elementen — een van de ingebouwde taalinstellingen van de app; elke andere waarde valt terug op de standaardtaalinstelling. Standaard `"en"`.

Een van `"en"`, `"es"`, `"zh"`, `"nl"`, `"pt"`, `"de"`, `"hu"`, `"it"`, `"fr"`, `"ja"`, `"pl"` of `"tr"`.

**environment** `"production" | "sandbox"`

Met welke Whop API-omgeving de elementen communiceren — `"sandbox"` richt zich op de sandbox-API (testgegevens; er wordt geen echt geld verplaatst). Het kiezen van een omgeving is de enige manier om te wijzigen waarheen de elementen versturen wat een koper typt, en beide omgevingen zijn van Whop zelf. De sandboxomgeving is nog niet algemeen beschikbaar. Standaard `"production"`.

**toasts** `boolean`

Of elementen toastmeldingen op je pagina mogen tonen — korte statusberichten ("Payment method added", "Payment failed") die rechtsonder worden weergegeven. Stel in op `false` om ze volledig uit te schakelen. Standaard `true`.

**skipPixel** `boolean`

Sla de Whop-pixel over. Standaard laden elementen de Whop-advertentiepixel op een pagina die deze nog niet uitvoert, met een scope voor het account waarvoor ze werken (de `accountId` van een elementgroep, of de verkoper van het abonnement van een checkout), en koppelen ze elementanalytics aan de bezoekers-ID van de pixel, een eenmalige identiteitskoppeling die elementactiviteit koppelbaar maakt aan je advertentie-attributiegegevens in de identiteitsgraaf van Whop. Stel in op `true` om geen van beide te doen. Gebruiksanalytics zelf worden niet beïnvloed (schakel die per handle uit met `analytics: false`). Standaard `false`.

```ts theme={null}
const whop = WhopElements({
  locale: 'es',
  appearance: { theme: { appearance: 'dark', accentColor: 'blue' } }
});
```

In React gaat hetzelfde object mee met `<WhopElements appearance={…} locale={…}>`.

De globale instelling `toasts` is live op deze pagina — de knop hieronder verstuurt er een via dezelfde rail die elementen gebruiken, met het thema van de `appearance` van deze pagina:

## Wat de elementen afhandelen en wat jij beheert

Elk element haalt zijn eigen gegevens op en geeft zijn eigen laad-, lege en foutstatussen weer.

Jij verzorgt **navigatie en opslag**. Elementen melden selecties en resultaten als events en schrijven nooit naar je database.

De uitzondering is een flow die de pagina verlaat. Wanneer een element een `returnUrl` accepteert, navigeert het het tabblad daarheen, zodat de koper buiten je pagina kan belanden. De koper komt daar terecht na een mislukte of afgebroken externe stap en ook na een geslaagde, met `status` (`succeeded`, `failed` of `canceled`) en het ID van de poging toegevoegd aan de URL, dus de pagina op `returnUrl` moet `status` lezen voordat die een succesmelding toont. Lever via webhooks in plaats van via een browsercallback.

Elementen draaien in frames, dus alleen serialiseerbare waarden gaan over de grens. Er is geen gedeelde DOM en objectidentiteit blijft niet behouden.

## Probleemoplossing

| Wat je ziet | Waarom |
| - | - |
| Lege ruimte in plaats van het element | Je CSP blokkeert `cdn.whop.com`. Voeg het toe aan `frame-src`, en aan `script-src` als je de scripttag gebruikt. |
| De console toont een schending van de Content Security Policy | Je beleid mist een bron. Vergelijk het met de tabel Vereisten. `contentSecurityPolicy()` retourneert elke bron in die tabel, en het script van een ander bedrijf kan zelf meer nodig hebben. |
| `mount()` doet niets | De selector kwam met geen enkele node overeen. Het doel moet al in de DOM staan. |
| Het element laadt maar blijft leeg | Het token mist een scope die dat element leest. Controleer de scopes op de pagina van het element. |
| Verzoeken mislukken op je eigen domein | Er is geen token meegegeven. De sessie-fallback werkt alleen op whop.com. |
| Het werkte en stopte toen | Het token is verlopen. Maak een nieuw token aan en geef het mee met `update({ accessToken })`. |

## Beschikbare elementen

> [card] [Payments](https://docs.whop.com/nl/elements/latest/payments/overview)
>
> Int een betaling op basis van een `plan_`-ID of een inline valuta en bedrag, of sla een betaalmethode op zonder af te schrijven met `mode: "setup"`.

> [card] [Verifications](https://docs.whop.com/nl/elements/latest/verifications/overview)
>
> Verzamelt en verifieert identiteitsgegevens voor een account.

> [card] [Checkout](https://docs.whop.com/nl/elements/latest/checkout/overview)
>
> Stuurt een volledige gehoste checkout aan voor een of meer abonnementen — gespecificeerd prijsoverzicht, promotiecodes, de valuta waarin de koper betaalt en het volledige oppervlak voor het innen van betalingen (de betaalelementen, daarbinnen samengesteld) — via de Whop checkout sessions API.

> [card] [Ads](https://docs.whop.com/nl/elements/latest/ads/overview)
>
> Een advertentieaccount.

> [card] [Tracking](https://docs.whop.com/nl/elements/latest/tracking/overview)
>
> Het gevolgde publiek van een account: iedereen die de pixel heeft gezien, en elk event dat ze hebben uitgevoerd.

> [card] [Wallet](https://docs.whop.com/nl/elements/latest/wallet/overview)
>
> Stuurt de geldoppervlakken van een account aan.

> [card] [Websites](https://docs.whop.com/nl/elements/latest/websites/overview)
>
> De websites van een account: elke site die op whop.site is gebouwd plus elk domein dat de Whop Pixel rapporteert, met verkeer en toegeschreven omzet per domein.

> [card] [Dashboard](https://docs.whop.com/nl/elements/latest/dashboard/overview)
>
> De eigen dashboardoppervlakken van een account, ingesloten op je site.

> [card] [Delivery](https://docs.whop.com/nl/elements/latest/delivery/overview)
>
> Leveringstracking voor klanten van een bedrijf.

> [card] [Chat](https://docs.whop.com/nl/elements/latest/chat/overview)
>
> Realtime chat met een kanalenlijst en zoeken in berichten.

## Volgende

* [Appearance](https://docs.whop.com/nl/elements/latest/appearance.md): thema's, CSS-variabelen en restyling per onderdeel
* [Create Access Token](https://docs.whop.com/nl/api-reference/access-tokens/create-access-token.md): het endpoint waarmee je server tokens aanmaakt

## Authenticatie

`getToken()` is je enige integratiepunt, en de SDK roept het **opnieuw aan voordat het token verloopt**, dus retourneer elke keer een nieuw token in plaats van er een te cachen:

```swift theme={null}
final class WalletTokenProvider: WhopTokenProvider {
    func getToken() async -> WhopTokenResponse {
        // your backend, not the Whop API directly
        WhopTokenResponse(accessToken: await myBackend.whopAccessToken())
    }
}
```

Configureer eenmaal, ergens boven de elementen. `WhopSDK` geldt voor het hele proces, dus een tweede aanroep is alleen nodig wanneer het account verandert:

```swift theme={null}
await WhopSDK.configure(tokenProvider: WalletTokenProvider())
```

Chat en DM's authenticeren de **kijker** in plaats van een account, via OAuth: `WhopSDK.configureWithOAuth(appId:)`.

## Thema's

`.whopTheme(_:)` wordt doorgegeven via de SwiftUI-omgeving, dus één aanroep geeft elk element eronder een thema. Zes rollen, elk een `WhopTint`:

```swift theme={null}
ListElement(accountId: "biz_xxxxxxxx")
    .whopTheme(WhopTheme(accent: .blue, danger: .red, success: .green))
```

De standaardwaarden zijn `accent: .blue`, `neutral: .gray`, `danger: .red`, `info: .sky`, `success: .green`, `warning: .amber`. `WhopTheme.default` bevat alle zes. Views volgen zelf de lichte/donkere weergave van het systeem.

## Wat de elementen afhandelen en wat jij beheert

Elke view haalt zijn eigen gegevens op en geeft zijn eigen laad-, lege en foutstatussen weer, inclusief een nieuwe poging. Jij beheert de **navigatie**: de selectiecallbacks geven je een waarde en pushen nooit een scherm.

```swift theme={null}
ListElement(accountId: account) { balance in
    path.append(Route.asset(balance.symbol))   // your router, your screen
}
```

## Probleemoplossing

| Wat je ziet | Waarom |
| - | - |
| `Authentication failed` | Het token ontbreekt, is verlopen of is een **API-sleutel** in plaats van een toegangstoken. `getToken()` moet een token retourneren dat is aangemaakt met [Create Access Token](https://docs.whop.com/nl/api-reference/access-tokens/create-access-token.md). |
| Een view blijft leeg | Het token is geldig, maar heeft geen scope voor die leesactie. Saldi vereisen `company:balance:read`. |
| `Couldn't load this account` | De `accountId` is er geen die dit token kan lezen. |
| Een grafiek zonder lijn | Saldogeschiedenis is alleen beschikbaar voor account-ID's met prefix `biz_`, niet voor persoonlijke accounts met prefix `user_`. |

## Beschikbaar op iOS

De wallet-views, elk met een live simulator op de eigen pagina:

* [`BalanceElement`](https://docs.whop.com/nl/elements/latest/wallet/balances-balance#swift): het totale saldo, de trend en de periodekiezer
* [`ListElement`](https://docs.whop.com/nl/elements/latest/wallet/balances-list#swift): de lijst met bezittingen
* [`ActivityElement`](https://docs.whop.com/nl/elements/latest/wallet/activity#swift): de activiteitenfeed van het grootboek

`WhopChatView` en `WhopDMsListView` worden in hetzelfde pakket geleverd voor chat met kijkerauthenticatie. Zie de [README](https://github.com/whopio/whopsdk-elements-swift).

## Betalingen op iOS

De betaalelementen worden geleverd vanuit een eigen pakket, [`whopio/elements-swift`](https://github.com/whopio/elements-swift), dat een `Elements`-module levert. De module van de wallet-SDK is `WhopElements`, dus de twee kunnen naast elkaar worden geïnstalleerd:

```swift theme={null}
dependencies: [
    .package(url: "https://github.com/whopio/elements-swift.git", from: "0.1.0")
]
```

De module is `Elements`, niet `WhopElements`, dus `import Elements` is de enige regel die verandert. Ook de setup verschilt, en die is opgesplitst zoals SwiftUI dat doet: configuratie wordt overgenomen van de app-root, en één afschrijving is een scope. Er is geen token nodig, omdat een bevestigingstoken wordt aangemaakt op basis van wat de koper heeft getypt en op je server is bevestigd:

```swift theme={null}
// once, at the app root
WindowGroup {
    CheckoutScreen()
        .whopElements(environment: .production)
}

// one charge, and the elements that collect for it
WhopPayments(accountID: "biz_xxxxxxxx", charge: .plan(id: "plan_xxxxxxxx")) { payments in
    WhopEmailElement()
    WhopPaymentElement()
    WhopBrandingElement()
    Button("Pay") { Task { try await payments.createConfirmationToken() } }
        .disabled(!payments.isComplete)
}
```

* [`WhopPaymentElement`](https://docs.whop.com/nl/elements/latest/payments/payment#swift): de methodetegels en wat de geselecteerde methode ook verzamelt
* [`WhopCardElement`](https://docs.whop.com/nl/elements/latest/payments/card#swift) en [`WhopCardFields`](https://docs.whop.com/nl/elements/latest/payments/cardFields#swift): de gehoste kaartinvoer, als één geheel of afzonderlijk geplaatst
* [`WhopAddressElement`](https://docs.whop.com/nl/elements/latest/payments/address#swift): het factuuradres, in het eigen formaat van het land
* [`WhopEmailElement`](https://docs.whop.com/nl/elements/latest/payments/email#swift) en [`WhopTaxIDElement`](https://docs.whop.com/nl/elements/latest/payments/taxId#swift)
* [`WhopBrandingElement`](https://docs.whop.com/nl/elements/latest/payments/branding#swift): vereist naast elk betaaloppervlak
* [`WhopPaymentRequest`](https://docs.whop.com/nl/elements/latest/payments/paymentRequest#swift): Apple Pay zonder gemount element

Kaartgegevens worden vastgelegd door PCI-geïsoleerde gehoste invoer en komen nooit in je proces terecht. Style alles met `.whopElementsAppearance(_:)` in plaats van `.whopTheme(_:)`.

## Authenticatie

`getToken` is je enige integratiepunt, en de SDK roept het **vóór elk verzoek** aan, dus retourneer een nieuw token in plaats van er een te cachen:

```tsx theme={null}
<WhopElements getToken={async () => (await fetch('/api/whop-token')).text()}>
  {/* your app */}
</WhopElements>
```

Een element dat geen referenties nodig heeft, werkt ook zonder, dus je kunt een kaartformulier weergeven voordat je je backend koppelt.

## Een betaling ontvangen

Verzamelen en bevestigen zijn gescheiden, en die scheiding is bewust: de app ziet nooit een kaartnummer en je server vertrouwt de client nooit.

1. De elementen verzamelen. Kaartnummers gaan rechtstreeks van PCI-geïsoleerde invoer naar een token, nooit via je code.
2. `createConfirmationToken()` retourneert een **bevestigingstoken**, dat veilig naar je eigen backend kan worden gestuurd.
3. Je backend bevestigt de betaling met de Whop API.
4. Als de API antwoordt dat de betaling meer van de koper nodig heeft, geef dan de `client_secret` ervan door aan `handleNextAction()` en de SDK voert de 3D Secure- of redirectstap uit.

```tsx theme={null}
const token = await payments.current!.createConfirmationToken();
const { status, clientSecret } = await myBackend.confirm(token.confirmationToken);
if (status === 'requires_action') await payments.current!.handleNextAction({ clientSecret });
```

## Redirects en 3D Secure

Stappen buiten de app openen de **systeembrowser** (`ASWebAuthenticationSession` op iOS, Custom Tabs op Android), nooit een WebView, zodat de pagina van de uitgever buiten de vertrouwensgrens van je app blijft en de cookies ervan buiten de cookie-opslag van je app.

Stel `returnUrl` op `<Payments>` in op een **https**-URL die je zelf host. De API weigert alles behalve https of loopback (`PaymentsApi::ValidateReturnUrl`), dus een aangepast app-schema werkt hier niet — en dat heb je ook niet nodig: `handleNextAction` pollt de betaling tot die in rust is en sluit de browser zelf, in plaats van te wachten op een deeplink terug naar je app.

```tsx theme={null}
<Payments accountId="biz_xxxxxxxx" plan="plan_xxxxxxxx" returnUrl="https://example.com/checkout/return">
```

## Apple Pay en Google Pay

Wallettegels verschijnen zodra het platform een sheet kan tonen, en voor geen van beide hoef je iets in te stellen. Apple Pay gebruikt de merchant die bij het Whop-account is geregistreerd, dus je app heeft geen merchant-ID en geen Xcode-capability nodig. `googlePayMerchantName` op `<Payments>` stelt alleen de naam in die in de sheet wordt getoond.

## Thema's

`appearance` op `<WhopElements>` geeft elk element eronder een thema, met hetzelfde `theme`-object dat de webelementen accepteren. Zie [Appearance](https://docs.whop.com/nl/elements/latest/appearance.md).

## Wat de elementen afhandelen en wat jij beheert

Elk element haalt zijn eigen gegevens op en geeft zijn eigen laad-, lege en foutstatussen weer. Jij beheert **navigatie en verzending**: de elementen melden via `onChange` en pushen nooit een scherm of roepen nooit je backend aan.

## Probleemoplossing

| Wat je ziet | Waarom |
| - | - |
| `BrandingRequiredError` bij bevestigen | Er is geen `BrandingElement` gemount. Mount er een binnen `<Payments>`. |
| `ChargeConfigError` | `<Payments>` heeft geen `plan` en ook geen combinatie van `amount` en `currency`. |
| Geen wallettegel | Het account heeft geen geregistreerde Apple Pay-merchant, of het apparaat kan geen sheet tonen. |
| Methodetegels verschijnen nooit | `getToken` retourneert een API-sleutel in plaats van een toegangstoken, of het token heeft geen scope voor het account. |
| Een leeg kaartveld | De native build is ouder dan het pakket. `@basis-theory/react-native-elements` wordt ermee meegeïnstalleerd, dus bouw opnieuw in plaats van het handmatig toe te voegen. |

## Beschikbaar in React Native

De betaalelementen:

* [`PaymentElement`](https://docs.whop.com/nl/elements/latest/payments/payment): de methodetegels en alles wat de geselecteerde methode nodig heeft
* [`AddressElement`](https://docs.whop.com/nl/elements/latest/payments/address): het factuuradres in het landformaat van de koper
* [`CardElement`](https://docs.whop.com/nl/elements/latest/payments/card): nummer, vervaldatum en beveiligingscode als één component
* [`CardFields`](https://docs.whop.com/nl/elements/latest/payments/cardFields): dezelfde drie velden, afzonderlijk geplaatst
* [`EmailElement`](https://docs.whop.com/nl/elements/latest/payments/email): het e-mailadres van de koper
* [`TaxIdElement`](https://docs.whop.com/nl/elements/latest/payments/taxId): een registratietype en -nummer
* [`BrandingElement`](https://docs.whop.com/nl/elements/latest/payments/branding): het Powered by Whop-merk, vereist op elk formulier

De checkoutelementen:

* [`ExpressCheckoutElement`](https://docs.whop.com/nl/elements/latest/checkout/expressCheckout): één druk op Apple Pay of Google Pay die een volledige checkout betaalt, onder `<Checkout>`


## Related topics

- [Aan de slag met Element Sessions](https://docs.whop.com/nl/sdk/elements/whop-elements.md)
- [Uitbetalingen voor subaccounts inschakelen](https://docs.whop.com/nl/developer/platforms/render-payout-portal.md)
- [Testen in de sandbox](https://docs.whop.com/nl/developer/guides/sandbox.md)
