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

# Gem betalingsmetoder

> Gem en kundes kort i setup-tilstand med betalingselementerne eller en hostet checkout eller under checkout, og opkræv derefter den gemte metode senere off-session.

Brug gemte betalingsmetoder til automatisk at opkræve kunder for abonnementer, fornyelser eller forbrugsbaseret fakturering. Kunden gemmer sit kort én gang via et Whop-hostet eller indlejret flow, og du kan opkræve det når som helst derefter.

> [!TIP]
>
> Kombiner denne guide med [webhooks](https://docs.whop.com/da/developer/guides/webhooks.md): lyt efter `setup_intent.succeeded` for at bekræfte, at metoden er gemt, og derefter efter `payment.succeeded` / `payment.failed` for at følge fremtidige opkrævninger.

## Vælg dit gem-flow

To veje, afhængigt af om brugeren også betaler lige nu.

| | Setup-tilstand (kun indsamling) | Gem under checkout |
| - | - | - |
| **Opkræver brugeren nu** | Nej | Ja |
| **Anvendelse** | Tilmelding til gratis prøveperiode, kort på fil før forbrugsbaseret fakturering | Abonnement, der fornyes efter den første betalte checkout |
| **Sådan** | Monter [betalingselementerne](https://docs.whop.com/da/elements/latest/payments/overview) i `mode: "setup"` og [opret en setup intent](https://docs.whop.com/da/api-reference/setup-intents/create-setup-intent.md) med bekræftelsestokenet, eller åbn en [checkout-konfiguration](https://docs.whop.com/da/api-reference/checkout-configurations/create-a-checkout-configuration.md) i setup-tilstand som en hostet checkout eller i [Checkout-elementet](https://docs.whop.com/da/elements/latest/checkout/overview) | Monter betalingselementerne med `setupFutureUsage: "off_session"`, og opret betalingen med bekræftelsestokenet |
| **Webhook at lytte efter** | `setup_intent.succeeded` | `payment.succeeded` (dens `payment_method_id` er den gemte metode) |

Resten af denne side gennemgår setup-tilstand fra start til slut og viser derefter, hvordan du opkræver en gemt metode senere.

## Gem en betalingsmetode med betalingselementerne

Byg gem-formularen på [betalingselementerne](https://docs.whop.com/da/elements/latest/payments/overview) i `mode: "setup"`. Elementet tilbyder kun metoder, der kan gemmes, viser køberen det samtykke til fremtidig brug, som lagringen kræver, og giver dig et bekræftelsestoken. Du omdanner tokenet til en setup intent fra din server, og setup intentens `client_secret` gennemfører ethvert trin, køberen mangler.

**1. Monter formularen i setup-tilstand**

Angiv `mode="setup"` og den valuta, den gemte metode skal bruges med. Der er intet beløb, så beløbsgrænser gælder ikke. Sæt `returnUrl` til en side, du hoster over `https`. Banktilmeldinger og nogle 3D Secure-flows sender køberen tilbage dertil.

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

export function SavePaymentMethodPage() {
  return (
    <WhopElements elements={loadWhop()}>
      <Payments
        accountId="biz_XXXXXXXX"
        mode="setup"
        currency="usd"
        returnUrl="https://yoursite.com/billing/saved"
      >
        <SaveForm />
      </Payments>
    </WhopElements>
  );
}

function SaveForm() {
  const payments = usePayments();
  const whop = useWhop();
  const [ready, setReady] = useState(false);
  const [error, setError] = useState<string | null>(null);

  async function save() {
    if (!payments || !whop) return;
    setError(null);

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      setError("The payment method couldn't be saved. Try a different one.");
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    setError(result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.");
  }

  return (
    <>
      <EmailElement />
      <PaymentElement onChange={(event) => setReady(event.complete)} />
      <BrandingElement />
      <button disabled={!ready} onClick={save}>
        Save payment method
      </button>
      {error && <p role="alert">{error}</p>}
    </>
  );
}
```

```html JavaScript theme={null}
<script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>

<div id="email"></div>
<div id="payment"></div>
<div id="branding"></div>
<button id="save" disabled>Save payment method</button>
<p id="error" role="alert"></p>

<script type="module">
  const whop = window.WhopElements();
  const payments = whop.payments.create({
    accountId: "biz_XXXXXXXX",
    mode: "setup",
    currency: "usd",
    returnUrl: "https://yoursite.com/billing/saved",
  });

  const saveButton = document.querySelector("#save");
  const errorLine = document.querySelector("#error");

  payments.create("email").mount("#email");
  payments
    .create("payment", { onChange: (event) => (saveButton.disabled = !event.complete) })
    .mount("#payment");
  payments.create("branding").mount("#branding");

  saveButton.addEventListener("click", async () => {
    errorLine.textContent = "";

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      errorLine.textContent = "The payment method couldn't be saved. Try a different one.";
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    errorLine.textContent = result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.";
  });
</script>
```

Tokenet indeholder det samtykke, elementet viste. Et token indsamlet fra en formular i betalingstilstand afvises af setup intenten, så monter i `mode="setup"`, når køberen ikke betaler.

**2. Opret setup intenten på din server**

[Opret en setup intent](https://docs.whop.com/da/api-reference/setup-intents/create-setup-intent.md) med bekræftelsestokenet. Whop finder køberen ud fra tokenets e-mail og svarer `201 Created` med setup intenten. Den indeholder `status`, en `client_secret` til ethvert trin, køberen mangler, og når den har status `succeeded`, den gemte metode som `payment_method_id`. Vedhæft `metadata` for at knytte den gemte metode til en kunde i dit system. Den kommer tilbage med webhooken. Send en [`Idempotency-Key`](https://docs.whop.com/da/developer/api/idempotency), så en gentaget request aldrig gemmer metoden to gange.

```typescript TypeScript theme={null}
import { WhopClient } from "@whop/sdk";

const client = new WhopClient({ token: process.env.WHOP_API_KEY });

export async function POST(request: Request) {
  const { confirmationToken } = await request.json();

  const setupIntent = await client.setupIntents.create({
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmationToken,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  });

  return Response.json({
    id: setupIntent.id,
    status: setupIntent.status,
    client_secret: setupIntent.client_secret,
  });
}
```

```python Python theme={null}
import os
from flask import Flask, jsonify, request
from whop_sdk import Whop

app = Flask(__name__)
client = Whop(token=os.environ["WHOP_API_KEY"])

@app.post("/api/save-payment-method")
def save_payment_method():
    setup_intent = client.setup_intents.create(
        request={
            "account_id": "biz_XXXXXXXX",
            "confirmation_token": request.get_json()["confirmationToken"],
            "currency": "usd",
            "return_url": "https://yoursite.com/billing/saved",
            "metadata": {"customer_id": "my_internal_user_id"},
        },
    )
    return jsonify(id=setup_intent.id, status=setup_intent.status, client_secret=setup_intent.client_secret)
```

```ruby Ruby theme={null}
require "whop_sdk"

client = Whop_sdk::Client.new(token: ENV.fetch("WHOP_API_KEY"))

post "/api/save-payment-method" do
  confirmation_token = JSON.parse(request.body.read)["confirmationToken"]

  setup_intent = client.setup_intents.create(
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmation_token,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  )

  { id: setup_intent.id, status: setup_intent.status, client_secret: setup_intent.client_secret }.to_json
end
```

**3. Gennemfør eventuelle ventende trin**

En setup intent, der kommer tilbage som `succeeded`, har metoden registreret. `requires_action` betyder, at køberen stadig mangler et trin som 3D Secure eller en banktilmelding. Send `client_secret` til `handleNextAction`, det samme kald som betalingsflowet bruger. Det kører et inline-trin i en dialog eller sender køberen til din `returnUrl`. Forgren på den `status`, det returnerer: `succeeded` har gemt metoden, `processing` afgøres stadig, og alt andet kræver et nyt forsøg. En lukket dialog efterlader opsætningen på `requires_action` uden fejl, og `lastPaymentError` indeholder årsagen, når forsøget mislykkes. `processing` betyder, at betalingsbehandleren stadig træffer afgørelse, så vis en ventetilstand, og lad webhooken nedenfor bekræfte lagringen. `canceled` betyder, at køberen opgav trinnet, eller at udbyderen afviste metoden: `last_setup_error` indeholder udbyderens årsag og forbliver `null`, når køberen gik fra det. For i stedet at læse tilstanden fra din server skal du [hente setup intenten](https://docs.whop.com/da/api-reference/setup-intents/retrieve-setup-intent.md) og forgrene på samme `status` eller polle det lettere [Retrieve setup status](https://docs.whop.com/da/api-reference/setup-intents/retrieve-setup-status.md), mens et trin venter.

**4. Håndter gennemførelse**

Lyt efter webhooken `setup_intent.succeeded` for at få betalingsmetodens ID og din `metadata` tilbage. Det er det eneste signal, der overlever en lukket fane, og den samme handler betjener det hostede flow nedenfor. Setup intenten indeholder også `payment_instrument` til visning: et navn, standardikonsættet og for et kort dets mærke, sidste fire cifre og udløbsdato. Du kan vise den gemte metode uden endnu en request. Webhooks, der er fastlåst før API-version 2026-09-22-1, angiver i stedet den gemte metode som `payment_method.id`.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

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

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Saved method:", setupIntent.payment_instrument?.display_name);
  console.log("Metadata:", setupIntent.metadata);
}
```

Betalingsmetoden er nu gemt og godkendt for dette medlem. Opkræv den med trinnene i [Opkræv en gemt betalingsmetode](#charge-a-saved-payment-method).

## Gem en betalingsmetode med en hostet checkout

**1. Opret en checkout-konfiguration i setup-tilstand**

[Opret en checkout-konfiguration](https://docs.whop.com/da/api-reference/checkout-configurations/create-a-checkout-configuration.md) uden en variant for at indsamle betalingsoplysninger uden at opkræve. Tilføj metadata, så du kan knytte medlemmet og betalingsmetoden til en kunde i dit system.

```typescript TypeScript theme={null}
const checkoutConfiguration = await whopsdk.checkoutConfigurations.create({
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
});
```

```python Python theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
    account_id="biz_XXXXXX",
    mode="setup",
    redirect_url="https://mywebsite.com/return_location",
    metadata={"customer_id": "my_internal_user_id"},
)
```

```ruby Ruby theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
)
```

```rust Rust theme={null}
let checkout_configuration = client
    .checkout_configurations
    .create(
        &CreateCheckoutConfigurationsRequest {
            account_id: Some("biz_XXXXXX".to_string()),
            mode: Some(CreateCheckoutConfigurationsRequestMode::Setup),
            redirect_url: Some("https://mywebsite.com/return_location".to_string()),
            metadata: Some(HashMap::from([(
                "customer_id".to_string(),
                json!("my_internal_user_id"),
            )])),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
checkoutConfiguration, err := client.CheckoutConfigurations.Create(context.TODO(), &whopsdk.CreateCheckoutConfigurationsRequest{
    AccountID:   whopsdk.String("biz_XXXXXX"),
    Mode:        whopsdk.CreateCheckoutConfigurationsRequestModeSetup.Ptr(),
    RedirectURL: whopsdk.String("https://mywebsite.com/return_location"),
    Metadata:    map[string]any{"customer_id": "my_internal_user_id"},
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(checkoutConfiguration.ID)
```

**2. Send brugeren til checkout**

Monter Checkout-elementet, eller omdiriger brugeren for at gemme sin betalingsmetode.

> [tab] Indlejret
>
> ```tsx theme={null}
> import { WhopElements, Checkout, CheckoutElement } from "@whop/elements-react";
> import { loadWhop } from "@whop/elements";
>
> export default function SavePayment({ configurationId }: { configurationId: string }) {
>   return (
>     <WhopElements elements={loadWhop()}>
>       <Checkout
>         checkoutConfiguration={configurationId}
>         returnUrl="https://yoursite.com/setup/complete"
>       >
>         <CheckoutElement />
>       </Checkout>
>     </WhopElements>
>   );
> }
> ```
>
> En konfiguration i setup-tilstand monterer det samme element som en lagring
> af betalingsmetode: der opkræves intet, og den gennemførte checkout omdirigerer til
> `returnUrl` med `setup_intent_id` i query-strengen. Bekræft lagringen
> ud fra webhooken `setup_intent.succeeded` i stedet for ud fra omdirigeringen.

> [tab] Omdirigering
>
> ```typescript theme={null}
> window.location.href = checkoutConfiguration.purchase_url;
> ```

**3. Håndter gennemførelse**

Lyt efter webhooken `setup_intent.succeeded` for at få betalingsmetodens ID. Setup intenten indeholder `checkout_configuration_id` og konfigurationens `metadata`, som du kan bruge til at knytte medlemmet og betalingsmetoden til en kunde i dit system.

> [!NOTE]
>
> Bekræft lagringen ud fra webhooken i stedet for ud fra, at køberen ankommer til din `redirect_url`. Det er det eneste signal, der overlever en lukket fane.

> [!TIP]
>
> Eksemplet bruger `waitUntil` fra `@vercel/functions` til at køre handleren efter at have svaret `200`. På andre runtimes (Bun, Cloudflare Workers, Fastify, Hono) skal du erstatte den med dit frameworks tilsvarende primitiv til baggrundsopgaver eller en jobkø. Se [webhooks-guiden](https://docs.whop.com/da/developer/guides/webhooks.md) for tilsvarende handlere i Python og Ruby.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

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

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Member ID:", setupIntent.member_id);
  console.log("Checkout configuration ID:", setupIntent.checkout_configuration_id);
  console.log("Metadata:", setupIntent.metadata);
}
```

Betalingsmetoden er nu gemt og godkendt for dette medlem.

## Opkræv en gemt betalingsmetode

**1. Hent betalingsmetoden**

[Vis gemte betalingsmetoder](https://docs.whop.com/da/api-reference/legacy/payment-methods/list-payment-methods.md) for et medlem, eller brug `payment_method_id` fra setup intenten i det forrige trin.

```typescript TypeScript theme={null}
const payment_methods = await whopsdk.paymentMethods.list({
  member_id: "mber_XXXXXXXX",
});

const payment_method = payment_methods.data[0];
```

```python Python theme={null}
payment_methods = whopsdk.payment_methods.list(member_id="mber_XXXXXXXX")
payment_method = payment_methods.items[0]
```

```ruby Ruby theme={null}
# list returns an Enumerable that pages for you; there is no `.data` on it
payment_method = whopsdk.payment_methods.list(member_id: "mber_XXXXXXXX").first
```

```rust Rust theme={null}
let payment_methods = client
    .payment_methods
    .list(
        &PaymentMethodsListQueryRequest {
            member_id: Some("mber_XXXXXXXX".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

let payment_method = &payment_methods.data[0];
```

```go Go theme={null}
page, err := client.PaymentMethods.List(context.TODO(), &whopsdk.ListPaymentMethodsRequest{
    MemberID: whopsdk.String("mber_XXXXXXXX"),
})
if err != nil {
    log.Fatal(err)
}

paymentMethod := page.Results[0]
fmt.Println(paymentMethod)
```

**2. Opret en off-session-betaling**

Opkræv betalingsmetoden uden kundeinteraktion. [Endpointet til oprettelse af betalinger](https://docs.whop.com/da/api-reference/payments/create-payment.md) returnerer straks et betalingsobjekt og behandler opkrævningen asynkront.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
});

console.log("Payment:", payment.id);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "member_id": "mber_XXXXXXXX",
        "payment_method_id": "payt_XXXXXXXXX",
    },
)

print("Payment:", payment.id)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
)

puts "Payment: #{payment.id}"
```

```rust Rust theme={null}
let payment = client
    .payments
    .create(
        &CreatePaymentsRequestBody::CreatePaymentsRequestBodyOne(
            CreatePaymentsRequestBodyOne::builder()
                .account_id("biz_XXXXXXXX")
                .variant_id("plan_XXXXXXXX")
                .member_id("mber_XXXXXXXX")
                .payment_method_id("payt_XXXXXXXXX")
                .build()
                .unwrap(),
        ),
        None,
    )
    .await?;

println!("Payment: {}", payment.payment_fields.id);
```

```go Go theme={null}
payment, err := client.Payments.Create(context.TODO(), &whopsdk.CreatePaymentsRequest{
    CreatePaymentsRequestOne: &whopsdk.CreatePaymentsRequestOne{
        AccountID:       "biz_XXXXXXXX",
        VariantID:       "plan_XXXXXXXX",
        MemberID:        "mber_XXXXXXXX",
        PaymentMethodID: whopsdk.String("payt_XXXXXXXXX"),
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println("Payment:", payment.ID)
```

> [!TIP]
>
> Du kan også sende `line_items` for at blande eksisterende varianter med priser oprettet inline. Hvert element tager præcis én af `variant_id` eller `variant`:
>
> ```json theme={null}
> {
>   "account_id": "biz_XXXXXXXX",
>   "member_id": "mber_XXXXXXXX",
>   "payment_method_id": "payt_XXXXXXXX",
>   "line_items": [
>     { "variant_id": "plan_XXXXXXXX", "quantity": 1 },
>     {
>       "variant": {
>         "product_id": "prod_XXXXXXXX",
>         "currency": "usd",
>         "billing_type": "one_time",
>         "initial_price": 7,
>         "allow_multiple_quantity": true
>       },
>       "quantity": 3
>     }
>   ]
> }
> ```
>
> Oprettelse af en variant kræver `plan:create` samt `payment:charge`. Genbrug af en matchende variant via `product_id` kræver kun `payment:charge`. En inline `product`-definition kræver også `access_pass:create` for at oprette produktet eller `access_pass:update` for at opdatere et eksisterende. Varianter skal tilhøre betalingskontoen og opfylde kurvens kompatibilitetsregler. Den inline `variant` bruger samme find-eller-opret-adfærd som en `variant` på øverste niveau. Angiv `force_create_new_plan: true` for at gennemtvinge en ny variant. Indlejrede variant- og produktfelter følger `Api-Version-Date`, og ukendte egenskaber afvises. Brug en `Idempotency-Key` til at gentage requesten uden at oprette endnu en betaling.
>
> For at give rabat skal du angive ID'et for en af dine [rabatkoder](https://docs.whop.com/da/manage-your-business/growth-marketing/promo-codes.md) som `promo_code_id`, så beregner Whop den nedsatte pris for dig. Rabatkoden skal være aktiv og gyldig for varianten, og varianten skal tilhøre et produkt.

**3. Håndter betalingshændelser**

Lyt efter betalings-webhooks for at følge, om betalinger lykkes eller mislykkes.

```typescript theme={null}
if (webhookData.type === "payment.succeeded") {
  await fulfillOrder(webhookData.data);
}

if (webhookData.type === "payment.failed") {
  await notifyCustomer(webhookData.data.customer_email, webhookData.data.failure_message);
}
```

## Gem under checkout

For at gemme en betalingsmetode, mens du opkræver køberen, skal du bygge checkouten på [betalingselementerne](https://docs.whop.com/da/elements/latest/payments/overview) og angive `setupFutureUsage: "off_session"` på `Payments`-handlet. Elementerne viser køberen samtykket til lagring og registrerer det på bekræftelsestokenet, og betalingen gemmer kun metoden, når samtykket er bekræftet.

Elements-egenskaben til valg af en variant hedder stadig `plan` af kompatibilitetshensyn.

**1. Monter formularen med samtykke til lagring**

```tsx theme={null}
<WhopElements elements={loadWhop()}>
  <Payments
    accountId="biz_XXXXXXXX"
    plan="plan_XXXXXXXX"
    setupFutureUsage="off_session"
    returnUrl="https://yoursite.com/checkout/complete"
  >
    <EmailElement />
    <PaymentElement onChange={(event) => setReady(event.complete)} />
    <BrandingElement />
  </Payments>
</WhopElements>
```

[Byg en checkout med betalingselementer](https://docs.whop.com/da/developer/guides/payment-elements.md) gennemgår betalingsknappen, `createConfirmationToken` og `handleNextAction`.

**2. Opret betalingen med bekræftelsestokenet**

Svaret på oprettelsen er betalingen, som den blev åbnet, ikke dens udfald. Den gemte metodes `payment_method_id` kommer med webhooken `payment.succeeded`, når opkrævningen er gennemført.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmationToken,
  return_url: "https://yoursite.com/checkout/complete",
});

console.log("Payment:", payment.id, payment.status);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "confirmation_token": confirmation_token,
        "return_url": "https://yoursite.com/checkout/complete",
    },
)

print("Payment:", payment.id, payment.status)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmation_token,
  return_url: "https://yoursite.com/checkout/complete",
)

puts "Payment: #{payment.id} #{payment.status}"
```

**3. Opkræv den senere**

`payment_method_id` er den `payt_`-metode, du skal bruge i [Opkræv en gemt betalingsmetode](#charge-a-saved-payment-method). Den forbliver `null`, når intet blev gemt. Webhooken `payment.succeeded` indeholder det samme felt, og det er den vej, der overlever en lukket fane.

## Næste trin

> [card] [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
>
> Engangs- og abonnementscheckouts, der passer til dit gem-flow.

> [card] [Checkout-elementet](https://docs.whop.com/da/elements/latest/checkout/overview)
>
> Monter Whop checkout på dit eget website med Whop Elements.

> [card] [Lyt efter webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Følg `setup_intent.succeeded`, `payment.succeeded` og `payment.failed`.

> [card] [Faktureringsportal](https://docs.whop.com/da/payments-and-billing/manage-billing/billing-portal.md)
>
> Lad kunder administrere og fjerne deres gemte betalingsmetoder.


## Related topics

- [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
- [Byg en checkout med Payment Elements](https://docs.whop.com/da/developer/guides/payment-elements.md)
- [Fakturaer](https://docs.whop.com/da/developer/guides/invoices.md)
