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

# Bir ödeme sayfası yerleştirin

> Checkout öğesiyle Whop'un ödeme sayfasının tamamını doğrudan tarayıcıdan sayfanıza ekleyin ve siparişi bir webhook üzerinden karşılayın

Checkout öğesiyle Whop'un ödeme sayfasının tamamını kendi sayfanıza yerleştirin. Tamamen tarayıcıda çalışır. Sunucunuz yalnızca alıcının ödeme yaptığını bildiren webhook'u dinler.

**Kod** altındaki dosyalar, aşağıdaki adımlara işaret eden `Step X.Y` yorumları içerir. Bir sunucu uygulaması ve bir istemci uygulaması seçin. Liste, her seçeneğin dosyalarını içerir.

## Ödeme sayfasını gömün

### 1.1 Paketleri kurun (React)

React için Whop Elements paketlerini kurun.

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

```bash pnpm theme={null}
pnpm add @whop/elements-react @whop/elements
```

### 1.1 Script etiketini ekleyin (JavaScript)

Ödeme sayfasını barındıran sayfaya Whop Elements betiğini yükleyin.

### 1.2 Checkout öğesini bağlayın

`CheckoutElement` öğesini bir `Checkout` tutamacının içine bağlayın ve varyantı mevcut `plan` özelliği üzerinden geçirin. Öğe ödeme oturumunu kendisi açar, siparişi fiyatlandırır ve satıcının ayarladığı her şeyi toplar. Sunucu koduna ve sayfada API anahtarına ihtiyaç duymaz: fiyatı varyant belirler, bu yüzden tarayıcı hiçbir zaman bir tutar beyan etmez.

Kendi sipariş kimliğiniz gibi `metadata` değerlerini tutamaçta geçirin. Whop bunu ödemeye ve onunla ilgili her webhook'a kopyalar. `returnUrl` değerini `https` üzerinden barındırdığınız bir sayfaya ayarlayın. Alıcı, 3D Secure, bir banka sayfası veya bir finansman başvurusu gibi site dışı bir ödeme adımından sonra oraya gelir. Sipariş kimliği gibi kendi sorgu parametrelerinizi ekleyin. Gidiş-dönüş boyunca korunurlar.

Bir ortaklık kodu, promosyon kodu veya kampanya atfı eklemek için tutamaçta `affiliateCode`, `promoCode` veya `attribution` geçirin. Sunucunuzda oluşturulan bir [ödeme yapılandırması](https://docs.whop.com/tr/api-reference/checkout-configurations/create-a-checkout-configuration.md) yalnızca bu ön ayarları istemci kodunun dışında tutmak istediğinizde gereklidir.

### 1.3 Tamamlanmayı kaydedin

`onComplete`, ödeme öğe içinde tamamlandığında, `returnUrl` adresine herhangi bir yönlendirmeden önce bir kez tetiklenir. Analitik ve reklam pikselleri için kullanın.

Teslimatı buradan yapmayın. Daha sonraki bir sayfa yüklemesinde geri yüklenen bir ödeme, aynı sonuç için onu tekrar tetikler ve site dışı bir ödeme adımı bunun yerine dönüş sayfasında tamamlanır.

## Dönüş sayfasını işleyin

### 2.1 Sonucu URL'den okuyun

Alıcı, site dışı adım sırasında **ne olursa olsun** `returnUrl` adresine gelir. Whop iki sorgu parametresi ekler. `payment`, `pay_` kimliğidir. `status`, alıcı ödeme yaptığında `succeeded`, yapmadığında ise `failed` veya `canceled` olur. Borç verenin reddettiği bir finansman başvurusu buraya `status=canceled` ile gelir; onaylanan bir başvuru ise tam olarak `status=succeeded` ile gelir.

`order` gibi kendi parametreleriniz URL'de kalır. Kart reddedilmeleri bu sayfaya asla ulaşmaz, çünkü öğe bunları satır içinde gösterir. Dönüş sayfası, sitenizin başarısız bir site dışı ödemeyi gördüğü tek yerdir.

### 2.2 Doğru görünümü gösterin

`status` değerine göre dallanın. `succeeded` teşekkür sayfasını alır. `failed` ve `canceled`, alıcıdan ücret alınmadığını belirten bir mesaj ve ödeme sayfasına geri dönen bir bağlantı alır. `processing` gibi diğer her şey, ücretin hâlâ beklemede olduğu anlamına gelir. Alıcıya e-postayla onaylayacağınızı söyleyin.

Sayfayı ödemenin kanıtı olarak değil, sonucun bir gösterimi olarak ele alın. Herkes bir URL'ye `status=succeeded` yazabilir. Erişim, indirmeler ve sipariş teslimatı sunucunuzdaki `payment.succeeded` webhook'undan gelir.

## Teslimatı sunucunuzdan yapın

### 3.1 Whop SDK'sını kurun (Next.js)

Webhook yardımcısı Whop SDK'sı ile birlikte gelir. Webhook'u alan sunucuya kurun.

```bash npm theme={null}
npm install @whop/sdk @vercel/functions
```

```bash pnpm theme={null}
pnpm add @whop/sdk @vercel/functions
```

### 3.1 Whop SDK'sını kurun (Express)

Webhook yardımcısı Whop SDK'sı ile birlikte gelir. Webhook'u alan sunucuya kurun.

```bash npm theme={null}
npm install @whop/sdk express
```

```bash pnpm theme={null}
pnpm add @whop/sdk express
```

### 3.1 Whop SDK'sını kurun (Python)

Webhook yardımcısı Whop SDK'sı ile birlikte gelir. Webhook'u alan sunucuya kurun.

```bash pip theme={null}
pip install whop-sdk fastapi
```

```bash poetry theme={null}
poetry add whop-sdk fastapi
```

### 3.2 Ödeme webhook'unu işleyin

Alıcı ödeme yaptıktan sonra Whop, webhook uç noktanıza `payment.succeeded` gönderir. İmzayı SDK yardımcısıyla doğrulayın, ardından teslimat işini yapın: siparişi ödendi olarak işaretleyin, erişim verin ve e-postayı gönderin. Ödeme, Checkout tutamacında ayarladığınız `metadata` değerini taşır.

Teslimat buraya aittir, başka hiçbir yere değil. Alıcı, dönüş sayfanız yüklenmeden tarayıcıyı kapatabilir, bir yönlendirme başarısız olabilir ve herkes bir sorgu parametresini elle yazabilir. Webhook'u oluşturmak ve `ws_` gizli anahtarını `WHOP_WEBHOOK_SECRET` olarak saklamak için [Webhook'lar kılavuzunu](https://docs.whop.com/tr/developer/guides/webhooks.md) izleyin.

## Kod

### İstemci: React — `CheckoutPage.tsx`

```tsx CheckoutPage.tsx theme={null}
// Step 1.1: Install the packages
import { Checkout, CheckoutElement, WhopElements } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function CheckoutPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			{/* Step 1.2: Mount the Checkout element */}
			<Checkout
				plan="plan_xxxxxxxxxxxxx"
				metadata={{ order_id: orderId }}
				returnUrl={`https://yoursite.com/checkout/return?order=${orderId}`}
				// Step 1.3: Record the completion
				onComplete={(completion) => {
					if (completion.result === "payment") {
						// Fire analytics or ad pixels here. Fulfill from the webhook, not from this callback.
						console.log("Checkout completed", completion.paymentId);
					}
				}}
			>
				{/* Step 1.2: Mount the Checkout element */}
				<CheckoutElement />
			</Checkout>
		</WhopElements>
	);
}
```

### İstemci: React — `CheckoutReturn.tsx`

```tsx CheckoutReturn.tsx theme={null}
export function CheckoutReturn() {
	// Step 2.1: Read the outcome from the URL
	// Whop appends `payment` and `status` to your returnUrl. Your own parameters (here `order`) survive.
	const params = new URLSearchParams(window.location.search);
	const paymentId = params.get("payment");
	const status = params.get("status");
	const orderId = params.get("order");

	// Step 2.2: Show the right face
	if (status === "succeeded") {
		return (
			<section>
				<h1>Thanks for your order</h1>
				<p>Payment {paymentId} is complete. A receipt is on its way to your email.</p>
			</section>
		);
	}

	if (status === "failed" || status === "canceled") {
		return (
			<section>
				<h1>Your payment did not go through</h1>
				<p>No money was taken. You can try again with another payment method.</p>
				<a href={`/checkout?order=${orderId}`}>Back to checkout</a>
			</section>
		);
	}

	return (
		<section>
			<h1>Confirming your payment</h1>
			<p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
		</section>
	);
}
```

### İstemci: JavaScript — `checkout.html`

```html checkout.html theme={null}
<!DOCTYPE html>
<html>
  <head>
    <!-- Step 1.1: Add the script tag -->
    <script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
  </head>
  <body>
    <div id="checkout"></div>

    <script type="module">
      const orderId = new URLSearchParams(window.location.search).get("order");

      // Step 1.2: Mount the Checkout element
      const checkout = window.WhopElements().checkout.create({
        plan: "plan_xxxxxxxxxxxxx",
        metadata: { order_id: orderId },
        returnUrl: `https://yoursite.com/checkout/return?order=${orderId}`,
        // Step 1.3: Record the completion
        onComplete: (completion) => {
          if (completion.result === "payment") {
            // Fire analytics or ad pixels here. Fulfill from the webhook, not from this callback.
            console.log("Checkout completed", completion.paymentId);
          }
        },
      });
      // Step 1.2: Mount the Checkout element
      checkout.create("checkout").mount("#checkout");
    </script>
  </body>
</html>
```

### İstemci: JavaScript — `return.html`

```html return.html theme={null}
<!DOCTYPE html>
<html>
  <body>
    <section id="succeeded" hidden>
      <h1>Thanks for your order</h1>
      <p>Payment <span id="payment-id"></span> is complete. A receipt is on its way to your email.</p>
    </section>
    <section id="failed" hidden>
      <h1>Your payment did not go through</h1>
      <p>No money was taken. You can try again with another payment method.</p>
      <a id="retry" href="/checkout">Back to checkout</a>
    </section>
    <section id="pending" hidden>
      <h1>Confirming your payment</h1>
      <p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
    </section>

    <script type="module">
      // Step 2.1: Read the outcome from the URL
      // Whop appends `payment` and `status` to your returnUrl. Your own parameters (here `order`) survive.
      const params = new URLSearchParams(window.location.search);
      const paymentId = params.get("payment");
      const status = params.get("status");
      const orderId = params.get("order");

      // Step 2.2: Show the right face
      if (status === "succeeded") {
        document.querySelector("#payment-id").textContent = paymentId;
        document.querySelector("#succeeded").hidden = false;
      } else if (status === "failed" || status === "canceled") {
        document.querySelector("#retry").href = `/checkout?order=${orderId}`;
        document.querySelector("#failed").hidden = false;
      } else {
        document.querySelector("#pending").hidden = false;
      }
    </script>
  </body>
</html>
```

### Sunucu: Next.js — `app/api/webhooks/whop/route.ts`

```typescript app/api/webhooks/whop/route.ts theme={null}
// Step 3.1: Install the Whop SDK
import { waitUntil } from "@vercel/functions";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
	// Step 3.2: Handle the payment webhook
	// Give the raw body. Parsing it first changes the bytes and the signature check fails.
	const payload = await request.text();
	const headers = Object.fromEntries(request.headers);

	const event = unwrapWebhook(payload, {
		headers,
		key: process.env.WHOP_WEBHOOK_SECRET!,
	});

	if (event.type === "payment.succeeded") {
		waitUntil(fulfillOrder(event.data));
	}

	// Respond in less than 5 seconds, or Whop retries.
	return new Response("OK", { status: 200 });
}

async function fulfillOrder(payment: Record<string, any>) {
	// Step 3.2: Handle the payment webhook
	// metadata.order_id is the value you set on the Checkout handle.
	const orderId = payment.metadata?.order_id;
	console.log(`[PAYMENT SUCCEEDED] ${payment.id} for order ${orderId}`);
	// Mark the order paid in your database and grant access here.
}
```

### Sunucu: Express — `server.ts`

```typescript server.ts theme={null}
// Step 3.1: Install the Whop SDK
import { unwrapWebhook } from "@whop/sdk/helpers";
import express from "express";

const app = express();

// Step 3.2: Handle the payment webhook
// Read the raw body on this route: parsing it first changes the bytes and the signature check fails.
app.post(
	"/api/webhooks/whop",
	express.raw({ type: "application/json" }),
	(req, res) => {
		const event = unwrapWebhook(req.body.toString("utf8"), {
			headers: req.headers,
			key: process.env.WHOP_WEBHOOK_SECRET!,
		});

		if (event.type === "payment.succeeded") {
			// metadata.order_id is the value you set on the Checkout handle.
			const orderId = event.data.metadata?.order_id;
			console.log(`[PAYMENT SUCCEEDED] ${event.data.id} for order ${orderId}`);
			// Mark the order paid in your database and grant access here.
		}

		// Respond in less than 5 seconds, or Whop retries.
		res.sendStatus(200);
	},
);

app.listen(3000);
```

### Sunucu: Python — `server.py`

```python server.py theme={null}
# Step 3.1: Install the Whop SDK
import os

from fastapi import BackgroundTasks, FastAPI, Request, Response
from whop_sdk.lib.verify_webhook import unwrap

app = FastAPI()


# Step 3.2: Handle the payment webhook
@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request, background: BackgroundTasks):
    # Give the raw body. Parsing it first changes the bytes and the signature check fails.
    payload = await request.body()

    event = unwrap(payload, dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "payment.succeeded":
        background.add_task(fulfill_order, event["data"])

    # Respond in less than 5 seconds, or Whop retries.
    return Response(status_code=200)


def fulfill_order(payment):
    # metadata.order_id is the value you set on the Checkout handle.
    order_id = (payment.get("metadata") or {}).get("order_id")
    print(f"[PAYMENT SUCCEEDED] {payment['id']} for order {order_id}")
    # Mark the order paid in your database and grant access here.
```

## Sonraki adımlar

* [Checkout öğesi referansı](https://docs.whop.com/tr/elements/latest/checkout/overview): Checkout tanıtıcısındaki tüm seçenekler, olaylar ve yöntemler.
* [Ödeme öğeleriyle bir ödeme sayfası oluşturun](https://docs.whop.com/tr/developer/guides/payment-elements.md): formu kendiniz tasarlayın ve ödemeyi sunucunuzdan onaylayın.
* [Webhook'lar](https://docs.whop.com/tr/developer/guides/webhooks.md): uç noktayı oluşturun, imzalama sırrını saklayın ve yeniden denemeleri yönetin.
* [Sandbox'ta test edin](https://docs.whop.com/tr/developer/guides/sandbox.md): başarılı olan, başarısız olan ve işlem gerektiren kartlarla bir test ödemesi yapın.


## Related topics

- [Express Checkout ekleyin](https://docs.whop.com/tr/developer/guides/express-checkout.md)
- [Whop API Hızlı Başlangıç](https://docs.whop.com/tr/developer/quickstart.md)
- [Payment Elements ile ödeme sayfası oluşturun](https://docs.whop.com/tr/developer/guides/payment-elements.md)
