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

# Kom godt i gang med Elements

> Installer Whop Elements, og montér dit første element i React, JavaScript, Swift eller React Native.

> [!NOTE]
>
> Denne side dokumenterer `@whop/elements@1.10.0` og `@whop/elements-react@1.10.0`.

Whop Elements er hostede UI-komponenter med temaunderstøttelse, som du indlejrer på dit eget website. Hvert element renderes i en isoleret frame, der leveres fra Whops CDN. Du installerer en tynd, fuldt typet pakke, og elementkoden holder sig selv opdateret.

Whop Elements er UI-komponenter med temaunderstøttelse, som du kan importere i din iOS-app. De leveres som en enkelt Swift SPM-pakke. Hver af dem er et almindeligt SwiftUI-view, der henter sine egne data og styrer sin egen tilstand, så en saldoskærm er et par views i en `VStack` i stedet for et netværkslag og en view model. Tilføj pakken, fortæl SDK'et, hvordan det henter et adgangstoken, og placér elementerne i dit view-hierarki.

Whop Elements er UI-komponenter med temaunderstøttelse, som du kan sætte direkte ind i en React Native-app. Det er ægte React Native-komponenter, ikke web views: felterne til betalingsmetoder, adresseformularen og kortfelterne er alle native input, og Apple Pay og Google Pay åbner platformens eget sheet. Installer pakken, fortæl SDK'et, hvordan det henter et adgangstoken, og montér elementerne.

## Installation

Tilføj pakken til din `Package.swift` (eller **File → Add Package Dependencies** i Xcode):

Installer SDK'et:

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

## Krav

| | |
| - | - |
| React | `^17.0.0 \|\| ^18.0.0 \|\| ^19.0.0`, til `@whop/elements-react`. |
| Content Security Policy | Din politik skal indeholde alle kilder i [tabellen over Content Security Policy](#content-security-policy) nedenfor. |

### Content Security Policy

| Krav | Direktiv | Produktionskilde | Sandbox-kilde |
| - | - | - | - |
| Elements-frames | `frame-src` | `https://cdn.whop.com` | Samme |
| Script-tagget, hvis du indlæser det | `script-src` | `https://cdn.whop.com` | Samme |
| Whop API | `connect-src` | `https://api.whop.com` | `https://sandbox-api.whop.com` |
| Whop-pixlen | `script-src` | `https://t.whop.tw` | Ingen |
| Whop-pixlen | `connect-src` | `https://t.whop.tw` | Ingen |
| Apple Pay, Google Pay og 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 og 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 og 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 og PayPal | `img-src` | `https://www.paypalobjects.com` | Samme |
| Tilknytning af bankkonto via Plaid | `frame-src` | `https://cdn.plaid.com` | Samme |
| Tilknytning af bankkonto via Plaid | `script-src` | `https://cdn.plaid.com` | Samme |
| Tilknytning af bankkonto via Plaid | `connect-src` | `https://production.plaid.com` | `https://sandbox.plaid.com` |

`contentSecurityPolicy()` fra `@whop/elements` returnerer alle kilder i denne tabel for det miljø, du angiver. Rækkerne for arbejde på sidesiden kører på din side, ikke i en frame. De scripts, som elementer indlæser til Apple Pay, Google Pay og PayPal samt tilknytning af bankkonto via Plaid, kommer fra andre virksomheder og kan indlæse ressourcer ud over disse rækker. Tjek også hver udbyders vejledning om Content Security Policy.

> [!WARNING]
>
> Elements renderes i frames, der leveres fra `cdn.whop.com`. Noget af deres arbejde kører på din side og kalder `api.whop.com` derfra, som Apple Pay, Google Pay og PayPal samt tilknytning af bankkonto via Plaid. Hvis din CSP blokerer en af de to origins, får du et tomt område i stedet for elementet eller en mislykket forespørgsel, og fejlen vises kun i browserkonsollen.

> [!NOTE]
>
> Et modalt element nedtoner din side bag sig med en inline-style. En `style-src`, der ikke tillader inline-styles, efterlader siden unedtonet, men modalen fungerer stadig.

## Før du starter

Du skal bruge to ting:

1. **Et `accountId`.** Et konto-ID med præfikset `biz_` eller et bruger-ID med præfikset `user_` til brugerens egne data. Betalingsflader tager i stedet en plan eller et beløb, og hver elementside angiver, hvad den kræver.
2. **Et server-endpoint, der opretter et adgangstoken**, afgrænset til de elementer, du monterer.

> [!WARNING]
>
> Placér aldrig en Whop API-nøgle i browserkode. Den opretter tokens, så alle, der åbner browserens udviklerværktøjer, kan læse kontoen. Opret tokenet på din server, og send kun tokenet.

Din server kalder [Create Access Token](https://docs.whop.com/da/api-reference/access-tokens/create-access-token.md) med kontoen og de scopes, elementerne kræver:

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

## Krav

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

## Før du starter

Du skal bruge to ting:

1. **Et `accountId`.** Et konto-ID med præfikset `biz_` eller et bruger-ID med præfikset `user_` til brugerens egen saldo.
2. **Et server-endpoint, der opretter et adgangstoken** til kontoen. Send aldrig en Whop API-nøgle med i appen. Den opretter tokens, så alle, der udtrækker den, kan læse kontoen. Opret tokenet på din server, og returnér kun det.

Et `user_…`-tag læser seerens egne data, så det bruger seer-OAuth (`WhopSDK.configureWithOAuth`) i stedet for et token. Det samme gør chat-views.

Din server kalder [Create Access Token](https://docs.whop.com/da/api-reference/access-tokens/create-access-token.md) med kontoen og det scope, elementerne kræver:

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

## Krav

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

> [!NOTE]
>
> **Begge iOS-afhængighedsmanagere fungerer.** Pakken leveres med både en `ios/Package.swift` og en podspec, og toolchainen vælger én. React Natives autolinker til Swift Package Manager foretrækker `Package.swift`, så en app, der allerede bruger SPM, påvirkes ikke af podspec'en. En app på CocoaPods, hvilket i dag omfatter alle Expo-apps, linker via podspec'en og behøver intet andet. Minimumsversionen af React Native er højere på SPM, fordi `Package.swift` linker to header-only XCFrameworks, der først blev leveret i 0.87.

> [!NOTE]
>
> Native kode er Swift og Kotlin genereret via React Native Codegen: intet her beder dig om at redigere Objective-C eller Java manuelt, og der er ingen native peer-afhængigheder at installere.

## Før du starter

Du skal bruge to ting:

1. **Et `accountId`.** Et virksomheds-ID med præfikset `biz_`.
2. **Et server-endpoint, der udsteder et adgangstoken** til den konto. Send aldrig en Whop API-nøgle med i appen: den opretter tokens, så alle, der udtrækker den, kan handle som kontoen. Udsted tokenet på din server, og returnér kun det.

Din server kalder [Create Access Token](https://docs.whop.com/da/api-reference/access-tokens/create-access-token.md) og giver resultatet tilbage til `getToken`.

## Montér dit første element

En komplet app. `configure` kører én gang ved opstart, og elementerne renderer en spinner, indtil den er færdig, så intet kommer i konflikt med den:

En komplet checkout. `<WhopElements>` holder token-resolveren, `<Payments>` holder opkrævningen, og elementerne imellem dem indsamler den:

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

Foretrækker du npm frem for script-tagget? `loadWhop()` indsætter det samme hostede script og resolver den globale constructor:

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

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

## Godkendelse

Angiv et `accessToken`, når du opretter handlet. **Brug ét token til hele handlet, ikke ét pr. element.** Handlet sender det token til alle elementer under det, så bed om alle de scopes, du har brug for, på det ene token. Hver elementside angiver de scopes, den læser.

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

Tokenet er en værdi, du angiver, ikke en callback, som SDK'et kalder. Sæt et nyt, før det udløber:

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

> [!NOTE]
>
> Hvis du udelader `accessToken`, bruger forespørgsler i stedet seerens sessionscookie. Dette fungerer **kun på whop.com**. API'et sender ikke `Access-Control-Allow-Credentials` ved cross-origin-preflights, så en side på dit eget domæne har ingen session at falde tilbage på og skal angive et token.

## Global konfiguration

Alt, hvad du angiver ved oprettelsen, gælder for alle elementgrupper, der oprettes fra den instans (et handles egne indstillinger kan tilsidesætte pr. gruppe):

**appearance** `Appearance`

Visuel tilpasning af alle elementer — `theme` (lys/mørk + paletter), `variables` (CSS custom properties) og `classes` (style-deklarationer pr. del). Farveskemaet anvendes før et elements første rendering, så mørke sider aldrig blinker lyst. Se [Appearance](https://docs.whop.com/da/elements/latest/appearance.md).

**locale** `string`

Sprog for elementernes UI-tekst — et af appens indbyggede sprog; enhver anden værdi falder tilbage til standardsproget. Standard er `"en"`.

En af `"en"`, `"es"`, `"zh"`, `"nl"`, `"pt"`, `"de"`, `"hu"`, `"it"`, `"fr"`, `"ja"`, `"pl"` eller `"tr"`.

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

Hvilket Whop API-miljø elementerne taler med — `"sandbox"` går til sandbox-API'et (testdata; ingen rigtige penge flyttes). Valg af miljø er den eneste måde at ændre, hvor elementerne sender det, en køber indtaster, og begge miljøer er Whops egne. Sandbox-miljøet er endnu ikke generelt tilgængeligt. Standard er `"production"`.

**toasts** `boolean`

Om elementer må vise toast-notifikationer på din side — korte statusbeskeder ("Payment method added", "Payment failed"), der renderes i nederste højre hjørne. Sæt `false` for at slå dem helt fra. Standard er `true`.

**skipPixel** `boolean`

Spring Whop-pixlen over. Som standard indlæser elementer Whop-annoncepixlen på en side, der ikke allerede kører den, afgrænset til den konto, de arbejder for (en elementgruppes `accountId` eller sælgeren af en checkouts plan), og knytter elementanalyser til pixlens besøgs-id, en engangskobling af identitet, der gør elementaktivitet mulig at sammenkøre med dine data om annonceattribution i Whops identitetsgraf. Sæt `true` for at gøre ingen af delene. Selve brugsanalyserne påvirkes ikke (slå dem fra pr. handle med `analytics: false`). Standard er `false`.

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

I React bæres det samme objekt af `<WhopElements appearance={…} locale={…}>`.

Den globale `toasts` er live på denne side — knappen nedenfor sender en via den samme kanal, som elementerne bruger, med denne sides `appearance` som tema:

## Hvad elementerne håndterer, og hvad du selv står for

Hvert element henter sine egne data og renderer sine egne tilstande for indlæsning, tomhed og fejl.

Du håndterer **navigation og lagring**. Elementer rapporterer valg og resultater som events og skriver aldrig til din database.

Undtagelsen er et forløb, der forlader siden. Hvor et element tager en `returnUrl`, navigerer det fanen dertil, så køberen kan ende uden for din side. Køberen ankommer dertil efter et mislykket eller afbrudt eksternt trin såvel som efter et vellykket, med `status` (`succeeded`, `failed` eller `canceled`) og forsøgets ID tilføjet til URL'en, så siden på `returnUrl` skal læse `status`, før den viser en succesbesked. Lever ud fra webhooks i stedet for ud fra en browser-callback.

Elementer kører i frames, så kun serialiserbare værdier krydser grænsen. Der er ingen delt DOM, og objektidentitet bevares ikke.

## Fejlfinding

| Hvad du ser | Hvorfor |
| - | - |
| Et tomt område i stedet for elementet | Din CSP blokerer `cdn.whop.com`. Tilføj det til `frame-src` og til `script-src`, hvis du bruger script-tagget. |
| Konsollen viser en overtrædelse af Content Security Policy | Din politik mangler en kilde. Sammenlign den med tabellen under Krav. `contentSecurityPolicy()` returnerer alle kilder i den tabel, og en anden virksomheds script kan kræve flere af sine egne. |
| `mount()` gør ingenting | Selektoren matchede ingen node. Målet skal allerede være i DOM'en. |
| Elementet indlæses, men forbliver tomt | Tokenet mangler et scope, som elementet læser. Tjek de scopes, der er angivet på elementets side. |
| Forespørgsler fejler på dit eget domæne | Der blev ikke angivet noget token. Session-fallbacken fungerer kun på whop.com. |
| Det virkede og holdt så op | Tokenet er udløbet. Opret et nyt, og angiv det med `update({ accessToken })`. |

## Tilgængelige elementer

> [card] [Payments](https://docs.whop.com/da/elements/latest/payments/overview)
>
> Indsaml en betaling ud fra et `plan_`-ID eller en inline valuta og et beløb, eller gem en betalingsmetode uden opkrævning med `mode: "setup"`.

> [card] [Verifications](https://docs.whop.com/da/elements/latest/verifications/overview)
>
> Indsamler og verificerer identitetsoplysninger for en konto.

> [card] [Checkout](https://docs.whop.com/da/elements/latest/checkout/overview)
>
> Driver en fuld hostet checkout for en eller flere planer — specificeret prisoversigt, rabatkoder, den valuta, køberen betaler i, og hele fladen til indsamling af betaling (betalingselementerne, sammensat indeni) — mod Whops API til checkout-sessioner.

> [card] [Ads](https://docs.whop.com/da/elements/latest/ads/overview)
>
> En annoncekonto.

> [card] [Tracking](https://docs.whop.com/da/elements/latest/tracking/overview)
>
> En kontos sporede målgruppe: alle, som dens pixel har set, og alle events, de har udført.

> [card] [Wallet](https://docs.whop.com/da/elements/latest/wallet/overview)
>
> Driver en kontos pengeflader.

> [card] [Websites](https://docs.whop.com/da/elements/latest/websites/overview)
>
> En kontos websites: alle sites bygget på whop.site plus alle domæner, som Whop Pixel rapporterer, med trafik og tilskrevet omsætning pr. domæne.

> [card] [Dashboard](https://docs.whop.com/da/elements/latest/dashboard/overview)
>
> En kontos egne dashboard-flader, indlejret på dit website.

> [card] [Delivery](https://docs.whop.com/da/elements/latest/delivery/overview)
>
> Leveringssporing for en virksomheds kunder.

> [card] [Chat](https://docs.whop.com/da/elements/latest/chat/overview)
>
> Realtidschat med en kanalliste og søgning i beskeder.

## Næste trin

* [Appearance](https://docs.whop.com/da/elements/latest/appearance.md): temaer, CSS-variabler og restyling pr. del
* [Create Access Token](https://docs.whop.com/da/api-reference/access-tokens/create-access-token.md): det endpoint, din server udsteder fra

## Godkendelse

`getToken()` er dit eneste integrationspunkt, og SDK'et kalder den **igen, før tokenet udløber**, så returnér et nyt token hver gang i stedet for at cache et:

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

Konfigurér én gang, et vilkårligt sted over elementerne. `WhopSDK` gælder for hele processen, så et andet kald er kun nødvendigt, når kontoen ændres:

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

Chat og DM'er godkender **seeren** i stedet for en konto via OAuth: `WhopSDK.configureWithOAuth(appId:)`.

## Temaer

`.whopTheme(_:)` udbredes gennem SwiftUI-miljøet, så ét kald giver alle elementer under det et tema. Seks roller, hver en `WhopTint`:

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

Standardværdierne er `accent: .blue`, `neutral: .gray`, `danger: .red`, `info: .sky`, `success: .green`, `warning: .amber`. `WhopTheme.default` er alle seks. Views følger selv systemets lyse/mørke udseende.

## Hvad elementerne håndterer, og hvad du selv står for

Hvert view henter sine egne data og renderer sine egne tilstande for indlæsning, tomhed og fejl, inklusive et genforsøg. Du står for **navigation**: valg-callbacks giver dig en værdi og skubber aldrig en skærm.

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

## Fejlfinding

| Hvad du ser | Hvorfor |
| - | - |
| `Authentication failed` | Tokenet mangler, er udløbet eller er en **API-nøgle** i stedet for et adgangstoken. `getToken()` skal returnere et token udstedt af [Create Access Token](https://docs.whop.com/da/api-reference/access-tokens/create-access-token.md). |
| Et view forbliver tomt | Tokenet er gyldigt, men ikke afgrænset til den læsning. Saldi kræver `company:balance:read`. |
| `Couldn't load this account` | `accountId` er ikke en, som dette token kan læse. |
| Et diagram uden linje | Saldohistorik er kun tilgængelig for konto-ID'er med præfikset `biz_`, ikke personlige konti med præfikset `user_`. |

## Tilgængeligt på iOS

Wallet-views, hver med en live simulator på sin side:

* [`BalanceElement`](https://docs.whop.com/da/elements/latest/wallet/balances-balance#swift): den samlede saldo, dens udvikling og periodevælgeren
* [`ListElement`](https://docs.whop.com/da/elements/latest/wallet/balances-list#swift): listen over beholdninger
* [`ActivityElement`](https://docs.whop.com/da/elements/latest/wallet/activity#swift): aktivitetsfeedet fra hovedbogen

`WhopChatView` og `WhopDMsListView` leveres i samme pakke til chat med seergodkendelse. Se [README](https://github.com/whopio/whopsdk-elements-swift).

## Betalinger på iOS

Betalingselementerne leveres fra deres egen pakke, [`whopio/elements-swift`](https://github.com/whopio/elements-swift), som udbyder et `Elements`-modul. Wallet-SDK'ets modul er `WhopElements`, så de to installeres side om side:

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

Modulet er `Elements`, ikke `WhopElements`, så `import Elements` er den eneste linje, der ændres. Opsætningen er også anderledes, og den deles op, som SwiftUI deler op: konfiguration nedarves fra app-roden, og én opkrævning er et scope. Intet kræver et token, fordi et bekræftelsestoken udstedes ud fra det, køberen har indtastet, og bekræftes på din server:

```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/da/elements/latest/payments/payment#swift): metodefelterne og det, den valgte metode indsamler
* [`WhopCardElement`](https://docs.whop.com/da/elements/latest/payments/card#swift) og [`WhopCardFields`](https://docs.whop.com/da/elements/latest/payments/cardFields#swift): de hostede kortinputs, som én enhed eller placeret enkeltvis
* [`WhopAddressElement`](https://docs.whop.com/da/elements/latest/payments/address#swift): faktureringsadressen i landets eget format
* [`WhopEmailElement`](https://docs.whop.com/da/elements/latest/payments/email#swift) og [`WhopTaxIDElement`](https://docs.whop.com/da/elements/latest/payments/taxId#swift)
* [`WhopBrandingElement`](https://docs.whop.com/da/elements/latest/payments/branding#swift): påkrævet ved siden af enhver betalingsflade
* [`WhopPaymentRequest`](https://docs.whop.com/da/elements/latest/payments/paymentRequest#swift): Apple Pay uden monteret element

Kortdata indsamles af PCI-isolerede hostede inputs og kommer aldrig ind i din proces. Style alt med `.whopElementsAppearance(_:)` i stedet for `.whopTheme(_:)`.

## Godkendelse

`getToken` er dit eneste integrationspunkt, og SDK'et kalder den **før hver forespørgsel**, så returnér et nyt token i stedet for at cache et:

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

Et element, der ikke kræver legitimationsoplysninger, fungerer uden den, så du kan rendere en kortformular, før du forbinder din backend.

## Modtag en betaling

Indsamling og bekræftelse er adskilt, og opdelingen er bevidst: appen ser aldrig et kortnummer, og din server stoler aldrig på klienten.

1. Elementerne indsamler. Kortnumre går direkte fra PCI-isolerede inputs til et token, aldrig gennem din kode.
2. `createConfirmationToken()` returnerer et **bekræftelsestoken**, som er sikkert at sende til din egen backend.
3. Din backend bekræfter betalingen med Whop API'et.
4. Hvis API'et svarer, at betalingen kræver mere fra køberen, så giv dens `client_secret` til `handleNextAction()`, og SDK'et kører 3D Secure- eller omdirigeringstrinnet.

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

## Omdirigeringer og 3D Secure

Trin uden for appen åbner **systembrowseren** (`ASWebAuthenticationSession` på iOS, Custom Tabs på Android), aldrig et WebView, så udstederens side forbliver uden for din apps tillidsgrænse, og dens cookies forbliver uden for din apps cookie-lager.

Sæt `returnUrl` på `<Payments>` til en **https**-URL, som du hoster. API'et afviser alt andet end https eller loopback (`PaymentsApi::ValidateReturnUrl`), så et brugerdefineret app-scheme virker ikke her — og du har ikke brug for et: `handleNextAction` poller betalingen, indtil den er afgjort, og lukker selv browseren i stedet for at vente på et deep link tilbage til din app.

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

## Apple Pay og Google Pay

Wallet-felter vises, når platformen kan præsentere et sheet, og der er intet at sætte op for nogen af dem. Apple Pay bruger den merchant, der er registreret på Whop-kontoen, så din app kræver ingen merchant identifier og ingen Xcode-capability. `googlePayMerchantName` på `<Payments>` angiver kun det navn, der vises i sheetet.

## Temaer

`appearance` på `<WhopElements>` giver alle elementer under det et tema med det samme `theme`-objekt, som webelementerne tager. Se [Appearance](https://docs.whop.com/da/elements/latest/appearance.md).

## Hvad elementerne håndterer, og hvad du selv står for

Hvert element henter sine egne data og renderer sine egne tilstande for indlæsning, tomhed og fejl. Du står for **navigation og indsendelse**: elementerne rapporterer via `onChange` og skubber aldrig en skærm eller kalder din backend.

## Fejlfinding

| Hvad du ser | Hvorfor |
| - | - |
| `BrandingRequiredError` ved bekræftelse | Der er ikke monteret noget `BrandingElement`. Montér ét inde i `<Payments>`. |
| `ChargeConfigError` | `<Payments>` har hverken en `plan` eller et par af `amount` og `currency`. |
| Intet wallet-felt | Kontoen har ingen registreret Apple Pay-merchant, eller enheden kan ikke præsentere et sheet. |
| Metodefelterne dukker aldrig op | `getToken` returnerer en API-nøgle i stedet for et adgangstoken, eller tokenet er ikke afgrænset til kontoen. |
| Et tomt kortfelt | Det native build er ældre end pakken. `@basis-theory/react-native-elements` installeres sammen med den, så byg igen i stedet for at tilføje den manuelt. |

## Tilgængeligt i React Native

Betalingselementerne:

* [`PaymentElement`](https://docs.whop.com/da/elements/latest/payments/payment): metodefelterne og alt, hvad den valgte metode kræver
* [`AddressElement`](https://docs.whop.com/da/elements/latest/payments/address): faktureringsadressen i køberens eget landeformat
* [`CardElement`](https://docs.whop.com/da/elements/latest/payments/card): nummer, udløbsdato og sikkerhedskode som én komponent
* [`CardFields`](https://docs.whop.com/da/elements/latest/payments/cardFields): de samme tre felter, placeret enkeltvis
* [`EmailElement`](https://docs.whop.com/da/elements/latest/payments/email): køberens e-mail
* [`TaxIdElement`](https://docs.whop.com/da/elements/latest/payments/taxId): en registreringstype og et registreringsnummer
* [`BrandingElement`](https://docs.whop.com/da/elements/latest/payments/branding): Powered by Whop-mærket, påkrævet på alle formularer

Checkout-elementerne:

* [`ExpressCheckoutElement`](https://docs.whop.com/da/elements/latest/checkout/expressCheckout): ét tryk på Apple Pay eller Google Pay, der betaler en hel checkout, under `<Checkout>`


## Related topics

- [Aktivér udbetalinger for underkonti](https://docs.whop.com/da/developer/platforms/render-payout-portal.md)
- [Kom i gang med Element Sessions](https://docs.whop.com/da/sdk/elements/whop-elements.md)
- [Tilmeld underkonti](https://docs.whop.com/da/developer/platforms/enroll-subaccounts.md)
