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

# Ödeme Yöntemlerini Kaydetme

> Bir müşterinin kartını ödeme öğeleri veya barındırılan bir ödeme sayfasıyla kurulum modunda ya da ödeme sırasında kaydedin, ardından kaydedilen yöntemden daha sonra oturum dışı ücret alın.

Abonelikler, yenilemeler veya kullanıma dayalı faturalandırma için müşterilerden otomatik olarak ücret almak üzere kayıtlı ödeme yöntemlerini kullanın. Müşteri kartını Whop'un barındırılan veya gömülü bir akışıyla bir kez kaydeder ve siz de sonrasında istediğiniz zaman ücret alabilirsiniz.

> [!TIP]
>
> Bu kılavuzu [webhook'larla](https://docs.whop.com/tr/developer/guides/webhooks.md) birlikte kullanın: kaydı doğrulamak için `setup_intent.succeeded` olayını, ardından gelecekteki ücretlendirmeleri takip etmek için `payment.succeeded` / `payment.failed` olaylarını dinleyin.

## Kaydetme akışınızı seçin

Kullanıcının şu anda ödeme de yapıp yapmadığına bağlı olarak iki yol vardır.

| | Kurulum modu (yalnızca toplama) | Ödeme sırasında kaydetme |
| - | - | - |
| **Kullanıcıdan şimdi ücret alır** | Hayır | Evet |
| **Kullanım durumu** | Ücretsiz deneme kaydı, kullanıma dayalı faturalandırma öncesinde kayıtlı kart | İlk ücretli ödemeden sonra yenilenen abonelik |
| **Nasıl** | [Ödeme öğelerini](https://docs.whop.com/tr/elements/latest/payments/overview) `mode: "setup"` ile yerleştirin ve onay token'ıyla [bir kurulum niyeti oluşturun](https://docs.whop.com/tr/api-reference/setup-intents/create-setup-intent.md) ya da kurulum modundaki bir [ödeme yapılandırmasını](https://docs.whop.com/tr/api-reference/checkout-configurations/create-a-checkout-configuration.md) barındırılan bir ödeme sayfası olarak veya [Checkout öğesinde](https://docs.whop.com/tr/elements/latest/checkout/overview) açın | Ödeme öğelerini `setupFutureUsage: "off_session"` ile yerleştirin ve ödemeyi onay token'ıyla oluşturun |
| **Dinlenecek webhook** | `setup_intent.succeeded` | `payment.succeeded` (`payment_method_id` değeri kaydedilen yöntemdir) |

Bu sayfanın geri kalanı kurulum modunu baştan sona ele alır, ardından kaydedilen bir yöntemden daha sonra nasıl ücret alınacağını gösterir.

## Ödeme öğeleriyle bir ödeme yöntemi kaydedin

Kaydetme formunu `mode: "setup"` ile [ödeme öğeleri](https://docs.whop.com/tr/elements/latest/payments/overview) üzerine kurun. Öğe yalnızca kaydedilebilen yöntemleri sunar, alıcıya kaydın gerektirdiği gelecekte kullanım onayını gösterir ve size bir onay token'ı verir. Bu token'ı sunucunuzdan bir kurulum niyetine dönüştürürsünüz; kurulum niyetinin `client_secret` değeri de alıcının henüz tamamlamadığı adımları bitirir.

**1. Formu kurulum modunda yerleştirin**

`mode="setup"` değerini ve kaydedilen yöntemin kullanılacağı para birimini iletin. Tutar olmadığı için tutar sınırları uygulanmaz. `returnUrl` değerini `https` üzerinden barındırdığınız bir sayfaya ayarlayın. Banka kayıtları ve bazı 3D Secure akışları alıcıyı oraya geri getirir.

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

Token, öğenin gösterdiği onayı taşır. Ödeme modundaki bir formdan toplanan token kurulum niyeti tarafından reddedilir; bu nedenle alıcı ödeme yapmıyorsa `mode="setup"` ile yerleştirin.

**2. Kurulum niyetini sunucunuzda oluşturun**

Onay token'ıyla [bir kurulum niyeti oluşturun](https://docs.whop.com/tr/api-reference/setup-intents/create-setup-intent.md). Whop alıcıyı token'daki e-postadan belirler ve kurulum niyetiyle birlikte `201 Created` yanıtı verir. Kurulum niyeti `status` değerini, alıcının henüz tamamlamadığı adımlar için bir `client_secret` değerini ve `succeeded` olduğunda kaydedilen yöntemi `payment_method_id` olarak taşır. Kaydedilen yöntemi sisteminizdeki bir müşteriye bağlamak için `metadata` ekleyin. Bu, webhook'ta geri gelir. Yeniden denenen bir isteğin yöntemi asla iki kez kaydetmemesi için bir [`Idempotency-Key`](https://docs.whop.com/tr/developer/api/idempotency) gönderin.

```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. Bekleyen adımları tamamlayın**

`succeeded` olarak dönen bir kurulum niyetinde yöntem kayıtlıdır. `requires_action`, alıcının hâlâ 3D Secure veya banka kaydı gibi bir adımı olduğu anlamına gelir. `client_secret` değerini, ödeme akışının kullandığı çağrıyla aynı olan `handleNextAction` fonksiyonuna iletin. Bu, bir diyalog içinde satır içi bir adım çalıştırır veya alıcıyı `returnUrl` adresinize gönderir. Döndürdüğü `status` değerine göre dallanın: `succeeded` yöntemin kaydedildiğini, `processing` kararın hâlâ verilmekte olduğunu gösterir; diğer her şey yeni bir deneme gerektirir. Kapatılan bir diyalog kurulumu hata olmadan `requires_action` durumunda bırakır ve deneme başarısız olduğunda `lastPaymentError` nedeni taşır. `processing`, işlemcinin hâlâ karar vermekte olduğu anlamına gelir; bu nedenle bekleme durumu gösterin ve kaydı aşağıdaki webhook'un doğrulamasına izin verin. `canceled`, alıcının adımı yarıda bıraktığı veya sağlayıcının yöntemi reddettiği anlamına gelir: `last_setup_error` sağlayıcının nedenini taşır ve alıcı vazgeçtiğinde `null` kalır. Durumu bunun yerine sunucunuzdan okumak için [kurulum niyetini alın](https://docs.whop.com/tr/api-reference/setup-intents/retrieve-setup-intent.md) ve aynı `status` değerine göre dallanın ya da bir adım beklemedeyken daha hafif olan [Kurulum durumunu al](https://docs.whop.com/tr/api-reference/setup-intents/retrieve-setup-status.md) uç noktasını yoklayın.

**4. Tamamlanmayı ele alın**

Ödeme yöntemi kimliğini ve `metadata` değerinizi geri almak için `setup_intent.succeeded` webhook'unu dinleyin. Kapatılan bir sekmeden sonra da ulaşan tek sinyal budur ve aynı işleyici aşağıdaki barındırılan akışa da hizmet eder. Kurulum niyeti, görüntüleme için `payment_instrument` değerini de taşır: bir ad, standart simge seti ve kart için markası, son dört hanesi ve son kullanma tarihi. Kaydedilen yöntemi başka bir istek yapmadan gösterebilirsiniz. API sürümü 2026-09-22-1 öncesine sabitlenmiş webhook'lar, kaydedilen yöntemi bunun yerine `payment_method.id` olarak taşır.

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

Ödeme yöntemi artık bu üye için kaydedilmiş ve yetkilendirilmiştir. [Kayıtlı bir ödeme yönteminden ücret alın](#charge-a-saved-payment-method) bölümündeki adımlarla ücret alın.

## Barındırılan bir ödeme sayfasıyla ödeme yöntemi kaydedin

**1. Kurulum modunda bir ödeme yapılandırması oluşturun**

Ücret almadan ödeme bilgilerini toplamak için varyant olmadan [bir ödeme yapılandırması oluşturun](https://docs.whop.com/tr/api-reference/checkout-configurations/create-a-checkout-configuration.md). Üyeyi ve ödeme yöntemini sisteminizdeki bir müşteriye bağlayabilmek için meta veri ekleyin.

```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. Kullanıcıyı ödeme sayfasına yönlendirin**

Kullanıcının ödeme yöntemini kaydetmesi için Checkout öğesini yerleştirin veya kullanıcıyı yönlendirin.

> [tab] Gömülü
>
> ```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>
>   );
> }
> ```
>
> Kurulum modundaki bir yapılandırma, aynı öğeyi bir ödeme yöntemi
> kaydı olarak yerleştirir: hiçbir ücret alınmaz ve tamamlanan ödeme sayfası
> sorgu dizesinde `setup_intent_id` ile `returnUrl` adresine yönlendirir. Kaydı
> yönlendirmeden değil, `setup_intent.succeeded` webhook'undan doğrulayın.

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

**3. Tamamlanmayı ele alın**

Ödeme yöntemi kimliğini almak için `setup_intent.succeeded` webhook'unu dinleyin. Kurulum niyeti, üyeyi ve ödeme yöntemini sisteminizdeki bir müşteriye bağlamak için kullanabileceğiniz `checkout_configuration_id` değerini ve yapılandırmanın `metadata` değerini taşır.

> [!NOTE]
>
> Kaydı, alıcının `redirect_url` adresinize ulaşmasından değil webhook'tan doğrulayın. Kapatılan bir sekmeden sonra da ulaşan tek sinyal budur.

> [!TIP]
>
> Örnek, `200` yanıtı verdikten sonra işleyiciyi çalıştırmak için `@vercel/functions` paketindeki `waitUntil` fonksiyonunu kullanır. Diğer çalışma ortamlarında (Bun, Cloudflare Workers, Fastify, Hono) bunu framework'ünüzün eşdeğer arka plan görevi yapısıyla veya bir iş kuyruğuyla değiştirin. Python ve Ruby işleyici eşdeğerleri için [webhook kılavuzuna](https://docs.whop.com/tr/developer/guides/webhooks.md) bakın.

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

Ödeme yöntemi artık bu üye için kaydedilmiş ve yetkilendirilmiştir.

## Kayıtlı bir ödeme yönteminden ücret alın

**1. Ödeme yöntemini alın**

Bir üye için [kayıtlı ödeme yöntemlerini listeleyin](https://docs.whop.com/tr/api-reference/legacy/payment-methods/list-payment-methods.md) veya önceki adımdaki kurulum niyetinden gelen `payment_method_id` değerini kullanın.

```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. Oturum dışı bir ödeme oluşturun**

Müşteri etkileşimi olmadan ödeme yönteminden ücret alın. [Ödeme oluşturma uç noktası](https://docs.whop.com/tr/api-reference/payments/create-payment.md) hemen bir ödeme nesnesi döndürür ve ücretlendirmeyi eşzamansız olarak işler.

```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]
>
> Mevcut varyantları satır içinde oluşturulan fiyatlandırmayla karıştırmak için `line_items` da gönderebilirsiniz. Her kalem, `variant_id` veya `variant` değerlerinden tam olarak birini alır:
>
> ```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
>     }
>   ]
> }
> ```
>
> Bir varyant oluşturmak, `payment:charge` izninin yanı sıra `plan:create` iznini de gerektirir. `product_id` ile eşleşen bir varyantı yeniden kullanmak yalnızca `payment:charge` gerektirir. Satır içi bir `product` tanımı ayrıca ürünü oluşturmak için `access_pass:create` veya mevcut bir ürünü güncellemek için `access_pass:update` gerektirir. Varyantlar ödeme hesabına ait olmalı ve sepetin uyumluluk kurallarını karşılamalıdır. Satır içi `variant`, üst düzey bir `variant` ile aynı bul-veya-oluştur davranışını kullanır. Yeni bir varyantı zorlamak için `force_create_new_plan: true` iletin. İç içe varyant ve ürün alanları `Api-Version-Date` değerini izler ve bilinmeyen özellikler reddedilir. İsteği başka bir ödeme oluşturmadan yeniden oynatmak için bir `Idempotency-Key` kullanın.
>
> İndirim uygulamak için [promosyon kodlarınızdan](https://docs.whop.com/tr/manage-your-business/growth-marketing/promo-codes.md) birinin kimliğini `promo_code_id` olarak iletin; Whop indirimli fiyatı sizin için hesaplar. Promosyon kodu etkin ve varyant için geçerli olmalı, varyant da bir ürüne ait olmalıdır.

**3. Ödeme olaylarını ele alın**

Başarıyı veya başarısızlığı takip etmek için ödeme webhook'larını dinleyin.

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

## Ödeme sırasında kaydedin

Alıcıdan ücret alırken bir ödeme yöntemini kaydetmek için ödeme sayfasını [ödeme öğeleri](https://docs.whop.com/tr/elements/latest/payments/overview) üzerine kurun ve `Payments` tanıtıcısında `setupFutureUsage: "off_session"` iletin. Öğeler alıcıya kaydetme onayını gösterir ve bunu onay token'ına kaydeder; ödeme de yöntemi yalnızca bu onay doğrulandığında kasaya kaydeder.

Bir varyant seçmeye yönelik Elements özelliği, uyumluluk için `plan` adını korur.

**1. Formu kaydetme onayıyla yerleştirin**

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

[Ödeme öğeleriyle bir ödeme sayfası oluşturun](https://docs.whop.com/tr/developer/guides/payment-elements.md) sayfası ödeme düğmesini, `createConfirmationToken` ve `handleNextAction` fonksiyonlarını adım adım anlatır.

**2. Ödemeyi onay token'ıyla oluşturun**

Oluşturma yanıtı, ödemenin sonucu değil, açıldığı hâlidir. Kaydedilen yöntemin `payment_method_id` değeri, ücretlendirme tamamlandığında `payment.succeeded` webhook'unda gelir.

```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. Daha sonra ücret alın**

`payment_method_id`, [Kayıtlı bir ödeme yönteminden ücret alın](#charge-a-saved-payment-method) bölümünde kullanılacak `payt_` yöntemidir. Hiçbir şey kaydedilmediğinde `null` kalır. `payment.succeeded` webhook'u aynı alanı taşır ve kapatılan bir sekmeden sonra da çalışan yol budur.

## Sonraki adımlar

> [card] [Ödeme kabul edin](https://docs.whop.com/tr/developer/guides/accept-payments.md)
>
> Kaydetme akışınızla birlikte kullanabileceğiniz tek seferlik ve abonelik ödeme sayfaları.

> [card] [Checkout öğesi](https://docs.whop.com/tr/elements/latest/checkout/overview)
>
> Whop Elements ile Whop ödeme sayfasını kendi sitenize yerleştirin.

> [card] [Webhook'ları dinleyin](https://docs.whop.com/tr/developer/guides/webhooks.md)
>
> `setup_intent.succeeded`, `payment.succeeded` ve `payment.failed` olaylarını takip edin.

> [card] [Faturalandırma portalı](https://docs.whop.com/tr/payments-and-billing/manage-billing/billing-portal.md)
>
> Müşterilerin kayıtlı ödeme yöntemlerini yönetmesine ve kaldırmasına izin verin.


## Related topics

- [Payment Elements ile ödeme sayfası oluşturun](https://docs.whop.com/tr/developer/guides/payment-elements.md)
- [Kurulum Amacı](https://docs.whop.com/tr/api-reference/legacy/setup-intents/setup-intent.md)
- [Faturalar](https://docs.whop.com/tr/developer/guides/invoices.md)
