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

# Forbind en PayPal-udbetalingsmetode

> Tilføj PayPal som udbetalingsmetode ved at lade kontoindehaveren logge ind på PayPal, så udbetalinger kun går til en verificeret konto i vedkommendes navn.

Sørg for, at udbetalinger kun når en PayPal-konto, som indehaveren ejer. Indehaveren logger ind på PayPal i stedet for at skrive en e-mail, og Whop gemmer PayPals e-mail, når navnet matcher vedkommendes udbetalingsopsætning.

| | Log ind med PayPal (denne guide) | Indtastet e-mail |
| - | - | - |
| **Udbetalings-e-mail** | Fra PayPal | Indtastet af indehaveren |
| **Beviser, at indehaveren ejer den** | Ja | Nej |
| **Integration** | En omdirigering og en returneringsside | Ét API-kald |

> [!NOTE]
>
> Før du starter, skal du have:
>
> * En API-nøgle med scopes `payout:destination:read` og `payout:create_destination`.
> * PayPal-login aktiveret på kontoen. Kontakt Whop for at få det slået til. Indtil da er `supports_paypal_login` `false`, og trin 2 returnerer `403`.
> * En gennemført [udbetalingsopsætning](https://docs.whop.com/da/developer/verification/overview.md). Whop matcher navnet i den med PayPal-kontoen.
> * En `https`-side, som PayPal kan sende indehaveren tilbage til, på et domæne, der er tilføjet til kontoen eller dens platform. Tilføj det med [Create Domain](https://docs.whop.com/da/api-reference/domains/create-domain.md) og `verification: {}`. Verificeringen behøver ikke at være fuldført. `https://localhost` virker til test.
> * Whop SDK 2.5.0 eller nyere, hvis du bruger et SDK.

## Sådan fungerer omdirigeringen

Det hele sker i indehaverens browser, i én fane. Du kalder aldrig PayPal direkte.

1. Din server starter en session og får en `authorize_url` hos PayPal.
2. Indehaverens browser går dertil, og vedkommende logger ind og godkender.
3. PayPal sender browseren tilbage til Whop, som læser kontoens e-mail, navn og verificeringsstatus.
4. Whop sender browseren til din `return_url` med `?paypal_link_token=…` eller `?error=…`.
5. Din server sender tokenet til Whop, som kontrollerer navnet og gemmer metoden.

## Find udbetalingsmetoden

[List understøttede udbetalingsmetoder](https://docs.whop.com/da/api-reference/payouts/list-supported-payout-methods.md), og gem `id` for den med `supports_paypal_login: true`. SDK'erne bladrer gennem alle resultater for dig.

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

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

const supportedMethods = await client.payouts.supportedMethods.list({
	account_id: "biz_xxxxxxxxxxxxx",
	destination_currency: "usd",
});

let paypalMethodId: string | undefined;
for await (const method of supportedMethods) {
	if (method.supports_paypal_login) {
		paypalMethodId = method.id;
		break;
	}
}
if (!paypalMethodId) throw new Error("PayPal login is not enabled for this account");
```

```python Python theme={null}
import os

from whop_sdk import Whop

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

supported_methods = client.payouts.supported_methods.list(
    account_id="biz_xxxxxxxxxxxxx",
    destination_currency="usd",
)

paypal_method_id = next(
    (method.id for method in supported_methods if method.supports_paypal_login),
    None,
)
if paypal_method_id is None:
    raise RuntimeError("PayPal login is not enabled for this account")
```

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

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

paypal_method = client.payouts.supported_methods
  .list(account_id: "biz_xxxxxxxxxxxxx", destination_currency: "usd")
  .find(&:supports_paypal_login)
raise "PayPal login is not enabled for this account" if paypal_method.nil?

paypal_method_id = paypal_method.id
```

```go Go theme={null}
import (
	"context"
	"fmt"
	"log"
	"os"

	whopsdk "github.com/whopio/whopsdk-go/v2"
	"github.com/whopio/whopsdk-go/v2/client"
	"github.com/whopio/whopsdk-go/v2/option"
	"github.com/whopio/whopsdk-go/v2/payouts"
)

ctx := context.TODO()
client := client.NewWhop(option.WithToken(os.Getenv("WHOP_API_KEY")))

page, err := client.Payouts.SupportedMethods.List(ctx, &payouts.ListSupportedMethodsRequest{
	AccountID:           whopsdk.String("biz_xxxxxxxxxxxxx"),
	DestinationCurrency: whopsdk.String("usd"),
})
if err != nil {
	log.Fatal(err)
}

var paypalMethodID string
methods := page.Iterator()
for methods.Next(ctx) {
	method := methods.Current()
	if method.SupportsPaypalLogin != nil && *method.SupportsPaypalLogin {
		paypalMethodID = method.ID
		break
	}
}
if err := methods.Err(); err != nil {
	log.Fatal(err)
}
if paypalMethodID == "" {
	log.Fatal("PayPal login is not enabled for this account")
}
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/supported_methods?account_id=biz_xxxxxxxxxxxxx&destination_currency=usd" \
  -H "Authorization: Bearer $WHOP_API_KEY"
```

## Start login

[Opret en PayPal-linksession](https://docs.whop.com/da/api-reference/payouts/create-paypal-link-session.md), og omdiriger indehaveren til dens `authorize_url`. Sessionen udløber efter 15 minutter, ved `expires_at`.

```typescript TypeScript theme={null}
const session = await client.payouts.paypalLinkSessions.create({
	account_id: "biz_xxxxxxxxxxxxx",
	supported_payout_method_id: paypalMethodId,
	destination_currency: "usd",
	return_url: "https://yourapp.example/settings/payouts",
});

// Redirect the holder's browser to this URL
console.log(session.authorize_url);
```

```python Python theme={null}
session = client.payouts.paypal_link_sessions.create(
    account_id="biz_xxxxxxxxxxxxx",
    supported_payout_method_id=paypal_method_id,
    destination_currency="usd",
    return_url="https://yourapp.example/settings/payouts",
)

# Redirect the holder's browser to this URL
print(session.authorize_url)
```

```ruby Ruby theme={null}
session = client.payouts.paypal_link_sessions.create(
  account_id: "biz_xxxxxxxxxxxxx",
  supported_payout_method_id: paypal_method_id,
  destination_currency: "usd",
  return_url: "https://yourapp.example/settings/payouts",
)

# Redirect the holder's browser to this URL
puts session.authorize_url
```

```go Go theme={null}
session, err := client.Payouts.PaypalLinkSessions.Create(ctx, &payouts.CreatePaypalLinkSessionsRequest{
	AccountID:               whopsdk.String("biz_xxxxxxxxxxxxx"),
	SupportedPayoutMethodID: paypalMethodID,
	DestinationCurrency:     whopsdk.String("usd"),
	ReturnURL:               "https://yourapp.example/settings/payouts",
})
if err != nil {
	log.Fatal(err)
}

// Redirect the holder's browser to this URL
fmt.Println(session.AuthorizeURL)
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/paypal_link_sessions" \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "account_id": "biz_xxxxxxxxxxxxx",
    "supported_payout_method_id": "podst_xxxxxxxxxxxxx",
    "destination_currency": "usd",
    "return_url": "https://yourapp.example/settings/payouts"
  }'
```

Browseren vender tilbage til din `return_url` med en af disse:

| Query-streng | Betydning | Næste |
| - | - | - |
| `?paypal_link_token=…` | Indehaveren loggede ind | Gem metoden inden for 15 minutter |
| `?error=paypal_login_canceled` | Indehaveren afbrød | Tilbyd at starte forfra |
| `?error=paypal_login_failed` | PayPal afviste, linket blev genbrugt, eller vekslingen mislykkedes | Start en ny session |

Hvis indehaveren bliver færdig efter `expires_at`, eller efter at `return_url`-domænet er fjernet fra kontoen, kan Whop ikke sende vedkommende tilbage. Vedkommende ser en side med "Invalid or expired link".

## Gem udbetalingsmetoden

[Opret den gemte udbetalingsmetode](https://docs.whop.com/da/api-reference/payouts/create-saved-payout-method.md) på din server med `paypal_link_token` i stedet for `fields`. Brug samme `account_id`, `supported_payout_method_id` og `destination_currency` som sessionen, da tokenet kun virker med dem. Whop gemmer PayPals e-mail og navngiver metoden efter den.

```typescript TypeScript theme={null}
// paypalLinkToken is the paypal_link_token from your return_url's query string
const method = await client.payouts.methods.create({
	account_id: "biz_xxxxxxxxxxxxx",
	supported_payout_method_id: paypalMethodId,
	destination_currency: "usd",
	paypal_link_token: paypalLinkToken,
});

console.log(method.id);
```

```python Python theme={null}
# paypal_link_token is the value from your return_url's query string
method = client.payouts.methods.create(
    account_id="biz_xxxxxxxxxxxxx",
    supported_payout_method_id=paypal_method_id,
    destination_currency="usd",
    paypal_link_token=paypal_link_token,
)

print(method.id)
```

```ruby Ruby theme={null}
# paypal_link_token is the value from your return_url's query string
method = client.payouts.methods.create(
  account_id: "biz_xxxxxxxxxxxxx",
  supported_payout_method_id: paypal_method_id,
  destination_currency: "usd",
  paypal_link_token: paypal_link_token,
)

puts method.id
```

```go Go theme={null}
// paypalLinkToken is the paypal_link_token from your return_url's query string
method, err := client.Payouts.Methods.Create(ctx, &payouts.CreateMethodsRequest{
	AccountID:               whopsdk.String("biz_xxxxxxxxxxxxx"),
	SupportedPayoutMethodID: paypalMethodID,
	DestinationCurrency:     whopsdk.String("usd"),
	PaypalLinkToken:         whopsdk.String(paypalLinkToken),
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(method.ID)
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/methods" \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "account_id": "biz_xxxxxxxxxxxxx",
    "supported_payout_method_id": "podst_xxxxxxxxxxxxx",
    "destination_currency": "usd",
    "paypal_link_token": "'"$PAYPAL_LINK_TOKEN"'"
  }'
```

Svaret er den nye udbetalingsmetode, forkortet:

```json theme={null}
{
	"object": "payout_method",
	"id": "potk_xxxxxxxxxxxxx",
	"nickname": "PayPal j•••@example.com",
	"institution_name": "PayPal",
	"destination_currency": "usd"
}
```

Du kan nu [sende en udbetaling](https://docs.whop.com/da/developer/platforms/manual-payouts.md) til den.

### Hvis Whop afviser kontoen

Whop svarer `400` med en `message` til indehaveren, f.eks. ved et navn, der ikke matcher. Vis den uændret.

* **Tokenet overlever en afvisning**, så prøv en midlertidig fejl igen med samme token.
* **Hvis beskeden siger, at PayPal skal forbindes igen**, så start en ny session, når indehaveren har løst problemet.
* **En ikke-verificeret PayPal-konto eller en ubekræftet e-mail gemmes stadig.**

## Hvad indehaveren ser

PayPals samtykkeskærm nævner Whop som den app, der beder om vedkommendes e-mail, navn og verificeringsstatus. Alle omdirigeringer forbliver i den fane, der åbnede PayPal, så hvis du bruger en pop-up, skal din returneringsside give besked til det vindue, der åbnede den, og lukke sig selv.

## Næste trin

> [card] [Send en udbetaling](https://docs.whop.com/da/developer/platforms/manual-payouts.md)
>
> Udbetal til den PayPal-metode, du lige har gemt

> [card] [API-reference for Payouts](https://docs.whop.com/da/api-reference/payouts/payout)
>
> Alle endpoints for udbetalinger og udbetalingsmetoder


## Related topics

- [Manuelle udbetalinger til underkonti](https://docs.whop.com/da/developer/platforms/manual-payouts.md)
- [PaymentRequest](https://docs.whop.com/da/elements/latest/payments/paymentRequest.md)
- [Create PayPal Link Session](https://docs.whop.com/da/api-reference/payouts/create-paypal-link-session.md)
