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

# Byg Whop-apps med React Native

> Byg en React Native-app, der kører i Whops mobilapp på iOS og Android samt på nettet.

Byg native iOS-, Android- og web-experiences til Whop med én enkelt React Native-kodebase. Dine apps kører direkte i Whops mobilapp og kan få adgang til native platformfunktioner.

## Sådan fungerer det

Whop indlejrer React Native-apps som experiences, der kører på flere platforme:

* **Mobil (iOS/Android)**: Apps kører native i Whops mobilapp med fuld platformintegration
* **Web**: Apps kører i browseren med automatiske fallbacks for platformspecifikke funktioner
* **Universel kode**: Skriv én gang, udrul overalt med platformspecifikke optimeringer

Din app modtager godkendt brugerkontekst og kan foretage API-kald via Whop SDK'et. Build-systemet håndterer automatisk platformspecifik bundling med Metro til mobil og esbuild til web.

***

## Kom i gang

### Systemkrav

Før du begynder, skal du sikre dig, at dit system opfylder følgende krav:

* [Node.js 22](https://nodejs.org/) eller nyere
* [pnpm 9.15](https://pnpm.io/) eller nyere

Kør `node -v` og `pnpm -v` for at tjekke.

### Opret din app

Opret en ny Whop React Native-app med CLI'en:

```bash theme={null}
pnpm create @whop/react-native@latest
```

Det opretter et nyt projekt med følgende struktur:

```
my-app/
├── src/
│   └── views/
│       ├── experience-view.tsx    # Experience view
│       ├── dashboard-view.tsx     # Account dashboard view
│       └── discover-view.tsx      # Discovery/marketplace view (optional)
├── .env.local                     # Environment variables
├── package.json
└── babel.config.js
```

### Konfigurer miljøvariabler

Opret en `.env.local`-fil i rodmappen:

```env theme={null}
WHOP_API_KEY=your_api_key
NEXT_PUBLIC_WHOP_APP_ID=your_app_id
NEXT_PUBLIC_WHOP_AGENT_USER_ID=your_agent_user_id
NEXT_PUBLIC_WHOP_COMPANY_ID=your_account_id
```

Hent disse legitimationsoplysninger fra [Whop Developer Dashboard](https://whop.com/dashboard/developer):

1. Gå til Whop Developer Dashboard
2. Opret en ny app, eller vælg en eksisterende
3. Kopiér miljøvariablerne fra appindstillingerne

***

## Visninger

![Projektstruktur](https://mintcdn.com/whop/qLWy5VwqPyIy4SPF/images/react-native-project-structure.png?fit=max\&auto=format\&n=qLWy5VwqPyIy4SPF\&q=85\&s=2252ed3982bb73023b2ccc70204071a0)

Whop-apps bruger forskellige "visninger" afhængigt af, hvor de vises. Hver visning modtager godkendt kontekst som props.

### Experience-visning

Hovedvisningen for experience-apps. Det er her, brugerne interagerer med indholdet i din app.

```tsx theme={null}
// src/views/experience-view.tsx
import React from "react";
import { View, Text, ScrollView } from "react-native";
import type { ExperienceViewProps } from "@whop/react-native";

export function ExperienceView(props: ExperienceViewProps) {
	const { experienceId, companyId, currentUserId, path, params } = props;

	return (
		<ScrollView>
			<Text>Experience: {experienceId}</Text>
			<Text>User: {currentUserId}</Text>
		</ScrollView>
	);
}
```

**Props:**

* `experienceId` - Experience-ID'et
* `companyId` - Den konto, der ejer denne experience
* `currentUserId` - Den godkendte bruger (eller `null`, hvis ikke logget ind)
* `path` - Navigationssti som array (f.eks. `["courses", "123"]`)
* `params` - Query-parametre som objekt

### Dashboard-visning

Til integrationer i kontoens dashboard, hvor sælgere administrerer deres virksomhed.

```tsx theme={null}
// src/views/dashboard-view.tsx
import React from "react";
import { View, Text } from "react-native";
import type { DashboardViewProps } from "@whop/react-native";

export function DashboardView(props: DashboardViewProps) {
	const { companyId, currentUserId, path, params } = props;

	return (
		<View>
			<Text>Dashboard for account: {companyId}</Text>
		</View>
	);
}
```

**Props:**

* `companyId` - Konto-ID'et
* `currentUserId` - Den godkendte bruger
* `path` - Navigationssti som array
* `params` - Query-parametre

### Discover-visning (valgfri)

Til markedsplads-/discovery-experiences, hvor brugere gennemser indhold.

```tsx theme={null}
// src/views/discover-view.tsx
import React from "react";
import type { DiscoverViewProps } from "@whop/react-native";

export function DiscoverView(props: DiscoverViewProps) {
	const { currentUserId, path, params } = props;

	// Your discovery UI
}
```

***

## Hentning af data

### Brug af Whop SDK'et

> [!WARNING]
>
> Dette eksempel bruger en forældet SDK-grænseflade. Det bliver opdateret, når
> det nye React Native SDK udkommer.

Whop SDK'et er tilgængeligt fra starten til datahentning på klientsiden:

```tsx theme={null}
import { whopSdk } from "@whop/react-native";
import { useQuery } from "@tanstack/react-query";

export function UserProfile() {
	const { data: user } = useQuery({
		queryKey: ["user"],
		queryFn: () => whopSdk.users.getCurrentUser(),
	});

	return <Text>{user?.name}</Text>;
}
```

> [!NOTE]
>
> [TanStack Query](https://tanstack.com/query/latest) er et godt valg til
> datahentning, fordi det automatisk håndterer caching, indlæsningstilstande og genhentning.

> [!WARNING]
>
> Nogle SDK-operationer er "kun til serveren" og skal kaldes fra dit API. Se
> [Quickstart](https://docs.whop.com/da/developer/quickstart.md) for, hvilke metoder der kræver
> udførelse på serversiden.

### Godkendte API-requests

Til operationer på serversiden skal du oprette API-ruter og kalde dem fra din React Native-app:

**1. Angiv din API-basis-URL**

Konfigurer din API-origin i [developer dashboard](https://whop.com/dashboard/developer) under **Base URL**.

![Base URL](https://mintcdn.com/whop/UNSo2mxrx93nOcNt/images/app-settings-base-url.png?fit=max\&auto=format\&n=UNSo2mxrx93nOcNt\&q=85\&s=67da3bca3f3a091176ced262b083b3ae)

**2. Opret et API-endpoint**

```tsx theme={null}
// app/api/user/route.ts
import { whopSdk } from "@/lib/whop";

export async function GET(request: Request) {
  const { userId } = await whopSdk.verifyUserToken(request.headers);
  const user = await whopSdk.users.getUser({ userId });

  return Response.json(user, { status: 200 });
}
```

Se [Quickstart](https://docs.whop.com/da/developer/quickstart.md) for SDK-konfiguration.

**3. Kald fra React Native**

Brug `apiOrigin` til at foretage godkendte requests:

```tsx theme={null}
import { useQuery } from "@tanstack/react-query";
import { __internal_execSync } from "@whop/react-native";

const { apiOrigin } = __internal_execSync("getAppApiOrigin", {});

export function User() {
  const { data: user, isPending } = useQuery({
    queryKey: ["user"],
    queryFn: () => fetch(`${apiOrigin}/api/user`).then((res) => res.json()),
  });

  if (isPending) return <Text>Loading...</Text>;

  return <Text>{user?.name}</Text>;
}
```

> [!NOTE]
>
> Det er vigtigt at bruge `apiOrigin` til godkendte requests. Det sikrer, at
> requests går gennem Whops proxy med korrekte godkendelsesheaders.

### Eksempel: Tjek adgang til en experience

```tsx theme={null}
// Component
import { useQuery } from "@tanstack/react-query";
import { __internal_execSync } from "@whop/react-native";

const { apiOrigin } = __internal_execSync("getAppApiOrigin", {});

export function ProtectedContent({ experienceId }: { experienceId: string }) {
	const { data: access, isPending } = useQuery({
		queryKey: ["access", experienceId],
		queryFn: () =>
			fetch(`${apiOrigin}/api/access?experienceId=${experienceId}`).then(
				(res) => res.json(),
			),
	});

	if (isPending) return <Text>Loading...</Text>;
	if (!access?.hasAccess) return <Text>Access Denied</Text>;

	return <Text>Welcome! You have access.</Text>;
}
```

> [!WARNING]
>
> Dette eksempel på serversiden bruger en forældet SDK-grænseflade. Se
> [Godkendelse](https://docs.whop.com/da/developer/guides/authentication.md) for aktuel tokenverifikation
> på serversiden med `@whop/sdk`.

```tsx theme={null}
// app/api/access/route.ts
import { whopSdk } from "@/lib/whop";
import { NextRequest } from "next/server";

export async function GET(request: NextRequest) {
	const experienceId = request.nextUrl.searchParams.get("experienceId");
	if (!experienceId) {
		return new Response("Experience ID required", { status: 400 });
	}

	const { userId } = await whopSdk.verifyUserToken(request.headers);

	const access = await whopSdk.access.checkIfUserHasAccessToExperience({
		experienceId,
		userId,
	});

	return Response.json(access, { status: 200 });
}
```

***

## Styling

### Farvetemaer

React Native har et `useColorScheme`-hook til at registrere enhedens farveskema. Det virker automatisk i Whop-apps:

```tsx theme={null}
import { useColorScheme } from "react-native";

export function ThemedView() {
	const colorScheme = useColorScheme();
	const backgroundColor = colorScheme === "dark" ? "#000" : "#fff";

	return <View style={{ backgroundColor }} />;
}
```

### Brug af Radix UI-farver

For et omfattende farvesystem med automatisk mørk tilstand kan du bruge `useColors`-hookmønsteret med Radix UI-farver:

```bash theme={null}
pnpm add @radix-ui/colors
```

```tsx theme={null}
// hooks/use-colors.ts
import { useColorScheme } from "react-native";
import {
	gray,
	grayA,
	grayDark,
	grayDarkA,
	blue,
	blueA,
	blueDark,
	blueDarkA,
	red,
	redA,
	redDark,
	redDarkA,
	green,
	greenA,
	greenDark,
	greenDarkA,
	amber,
	amberA,
	amberDark,
	amberDarkA,
} from "@radix-ui/colors";

export function useColors() {
	const colorScheme = useColorScheme();
	const isDark = colorScheme === "dark";

	return {
		transparent: "transparent" as const,
		...(isDark ? grayDark : gray),
		...(isDark ? grayDarkA : grayA),
		...(isDark ? blueDark : blue),
		...(isDark ? blueDarkA : blueA),
		...(isDark ? redDark : red),
		...(isDark ? redDarkA : redA),
		...(isDark ? greenDark : green),
		...(isDark ? greenDarkA : greenA),
		...(isDark ? amberDark : amber),
		...(isDark ? amberDarkA : amberA),
	};
}
```

**Brug:**

```tsx theme={null}
export function StyledComponent() {
	const colors = useColors();

	return (
		<View style={{ backgroundColor: colors.gray1 }}>
			<Text style={{ color: colors.gray12 }}>Themed text</Text>
		</View>
	);
}
```

***

## Navigation

Brug de interne navigations-API'er til at navigere mellem skærme og vise modaler:

### Naviger til en ny skærm

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

function navigateToPage() {
	__internal_execSync("routerPush", {
		path: ["courses", "123"],
		params: { section: "intro" },
	});
}
```

Whop sender `path` og `params` som props til din visningskomponent.

### Gå tilbage

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

function goBack() {
	__internal_execSync("routerPop", {});
}
```

### Vis et ark eller en modal

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

function showModal() {
	__internal_execSync("routerPresentSheet", {
		path: ["modal", "settings"],
		params: {},
	});
}

function hideModal() {
	__internal_execSync("routerDismissSheet", {});
}
```

### Hent den aktuelle rute

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

const currentRoute = __internal_execSync("routerGetCurrent", {});
console.log(currentRoute.path); // ["courses", "123"]
console.log(currentRoute.params); // { section: "intro" }
```

***

## Platformspecifikke funktioner

### Navigationslinje

Konfigurer navigationslinjens titel og beskrivelse:

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

__internal_execSync("setNavigationBarData", {
	title: "Course Details",
	description: "Learn React Native",
});
```

### Skærmretning

Styr skærmretningen:

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

// Lock to portrait
__internal_execSync("setScreenOrientationMode", {
	targetScreenOrientationMode: "portrait",
});

// Lock to landscape
__internal_execSync("setScreenOrientationMode", {
	targetScreenOrientationMode: "landscape",
});

// Allow rotation
__internal_execSync("setScreenOrientationMode", {
	targetScreenOrientationMode: "rotate",
});
```

### Haptisk feedback

Giv haptisk feedback på mobile enheder:

```tsx theme={null}
import { Haptics } from "@whop/react-native";

async function triggerHaptic() {
	await Haptics.trigger("impactMedium", {
		enableVibrateFallback: true,
		ignoreAndroidSystemSettings: false,
	});
}
```

**Tilgængelige haptiske typer:**

* `"selection"` - Let feedback ved valg
* `"impactLight"` | `"impactMedium"` | `"impactHeavy"` - Feedback ved stød
* `"notificationSuccess"` | `"notificationWarning"` | `"notificationError"` - Feedback ved notifikationer

### Lokal caching

Gem data lokalt på enheden:

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

// Save data
__internal_execSync("cacheSet", {
	key: "user_preferences",
	data: JSON.stringify({ theme: "dark" }),
});

// Retrieve data
const result = __internal_execSync("cacheGet", {
	key: "user_preferences",
});
const preferences = JSON.parse(result.data || "{}");
```

### Oplysninger om værtsappen

Hent oplysninger om Whop-appen:

```tsx theme={null}
import { __internal_execSync } from "@whop/react-native";

const hostDetails = __internal_execSync("getHostAppDetails", {});
console.log(hostDetails.platform); // "ios" | "android" | "web"
console.log(hostDetails.version); // "1.2.3"
console.log(hostDetails.build); // "123"
console.log(hostDetails.buildType); // "appstore" | "testflight" | "debug"
```

***

## Køb i appen

Modtag betalinger direkte i din app:

```tsx theme={null}
import { __internal_execAsync } from "@whop/react-native";

async function handlePurchase(planId: string) {
	try {
		const result = await __internal_execAsync("inAppPurchase", {
			planId: planId,
			id: "optional-checkout-config-id",
		});

		console.log("Payment successful!");
		console.log("Session ID:", result.sessionId);
		console.log("Receipt ID:", result.receiptId);

		// Unlock content for user
	} catch (error) {
		console.error("Payment failed:", error);
	}
}
```

Se [dokumentationen om at modtage betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md) for en komplet guide.

***

## Brug af tredjepartsbiblioteker

De fleste React Native-biblioteker virker uden videre. Her er de anbefalede versioner af almindelige biblioteker:

```json theme={null}
{
	"dependencies": {
		"@react-native-async-storage/async-storage": "2.1.0",
		"@react-native-community/netinfo": "12.0.3",
		"@shopify/flash-list": "1.7.2",
		"burnt": "0.13.2",
		"react-native-mmkv": "3.1.0",
		"react-native-safe-area-context": "5.5.2",
		"react-native-screens": "4.6.0",
		"react-native-svg": "15.12.0",
		"react-native-gesture-handler": "2.27.2",
		"react-native-reanimated": "3.18.0",
		"react-native-haptic-feedback": "2.3.3",
		"lottie-react-native": "7.3.2"
	}
}
```

> [!WARNING]
>
> Når du tilføjer nye biblioteker, skal du sikre dig, at de er kompatible med React Native.
> Nogle npm-pakker er kun til web og virker ikke på mobile platforme.

***

## Udrulning

### Byg og udrul

Kommandoen `ship` bygger din app til alle platforme og uploader den som et udviklingsbuild:

```bash theme={null}
pnpm ship
```

Byg til bestemte platforme:

```bash theme={null}
pnpm ship --ios           # iOS only
pnpm ship --android       # Android only
pnpm ship --web          # Web only
pnpm ship --ios --android # iOS and Android
```

> [!NOTE]
>
> Kommandoen `ship` udruller som et **udviklingsbuild**, som er sikkert at køre på
> eksisterende produktionsapps. Det påvirker ikke dine live brugere.

### Udviklings- og produktionsbuilds

**Udviklingsbuilds:**

* Udrulles med `pnpm ship`
* Kun synlige, når du aktiverer **Dev mode** (ryst telefonen)
* Sikre at teste uden at påvirke produktionsbrugere
* Du kan udrulle dem når som helst

**Produktionsbuilds:**

* Forfremmes fra udviklingsbuilds via dashboardet
* Synlige for alle brugere
* Kræver godkendelse/gennemgang
* Test dem før forfremmelse

### Forhåndsvis din app

Når du har udrullet et udviklingsbuild, kan du forhåndsvise det på din enhed:

```bash theme={null}
pnpm preview
```

Det genererer en QR-kode, der installerer din app.

> [!WARNING]
>
> For at forhåndsvise udviklingsbuilds skal du **ryste din telefon** for at aktivere **Dev
> mode** i Whop-appen. Så kan du se builds, der ikke er produktionsbuilds.

### Build-kommandoer

Yderligere kommandoer til at administrere builds:

```bash theme={null}
pnpm build         # Build without uploading
pnpm upload        # Upload previously built files
pnpm clean         # Clean build directory
```

### Forfremmelse til produktion

1. Udrul et udviklingsbuild: `pnpm ship`
2. Test i **Dev mode** (ryst for at aktivere)
3. Gå til dit [app-dashboard](https://whop.com/dashboard/developer)
4. Gå til fanen Builds
5. Vælg dit udviklingsbuild
6. Vælg **Promote to Production**

![Forfrem til produktion](https://mintcdn.com/whop/qLWy5VwqPyIy4SPF/images/promote-build.png?fit=max\&auto=format\&n=qLWy5VwqPyIy4SPF\&q=85\&s=9e428a92b24390c4b8db785a55b59b57)

Whop gennemgår din app og udruller den til alle brugere efter godkendelse.

### Rollback

Fra builds-skærmen kan du også øjeblikkeligt rulle tilbage til et tidligere produktionsbuild og sende det live til alle brugere på Whop.

![Rollback](https://mintcdn.com/whop/qLWy5VwqPyIy4SPF/images/rollback-build.png?fit=max\&auto=format\&n=qLWy5VwqPyIy4SPF\&q=85\&s=c406c17b97bad3f4241749c45741b33e)

***

## Reference for kommandolinjegrænsefladen

CLI'en `@whop/react-native` har kommandoer til at bygge og udrulle din app:

### Kommandoer

```bash theme={null}
pnpm ship [--ios] [--android] [--web]    # Build + upload development build
pnpm build [--ios] [--android] [--web]   # Build only (no upload)
pnpm upload [--ios] [--android] [--web]  # Upload existing build/
pnpm clean                                # Clean build directory
pnpm preview                              # Generate install QR code
```

### Build-processen

Når du kører `pnpm ship`, gør CLI'en følgende:

1. **Genererer entrypoints** - Opretter platformspecifikke indgangsfiler, der registrerer dine visninger
2. **Bundler kode**:
   * **Mobil (iOS/Android)**: Bruger Metro-bundleren + Hermes-bytecode-compileren
   * **Web**: Bruger esbuild med React Native Web-aliasser
3. **Pakker assets** - Indsamler og optimerer billeder og andre assets
4. **Uploader til Whop** - Opretter et udviklingsbuild i dit app-dashboard
5. **Genererer installationslink** - Giver en QR-kode til test

### Build-output

```
build/
├── entrypoints/        # Generated entry files
│   ├── ios/
│   ├── android/
│   └── web/
├── output/            # Compiled bundles
│   ├── ios/
│   │   └── main_js_bundle.hbc
│   ├── android/
│   │   └── main_js_bundle.hbc
│   └── web/
│       ├── main.js
│       └── index.html
└── app_build_*.zip   # Packaged builds
```

***

## Fejlfinding

### Udviklingsbuild vises ikke

**Problem**: Du har udrullet et udviklingsbuild, men kan ikke se det i appen.

**Løsning**: Ryst din telefon for at aktivere **Dev mode**. Udviklingsbuilds er kun synlige, når **Dev mode** er aktiv.

### Build-fejl

**Problem**: Buildet fejler med Metro- eller esbuild-fejl.

**Løsninger**:

* Kør `pnpm clean` for at rydde build-cachen
* Tjek, at du har installeret alle afhængigheder: `pnpm install`
* Verificer Node.js-versionen: `node -v` (bør være 22+)
* Tjek for syntaksfejl i dine visninger

### API-requests virker ikke

**Problem**: API-requests returnerer 401 eller godkendelsesfejl.

**Løsninger**:

* Verificer, at du bruger `apiOrigin` fra `__internal_execSync("getAppApiOrigin", {})`
* Tjek, at `.env.local` angiver `WHOP_API_KEY`
* Bekræft, at dit API-endpoint kalder `whopSdk.verifyUserToken(request.headers)`
* Verificer, at basis-URL'en er angivet korrekt i dashboardet

### Visninger blev ikke fundet

**Problem**: Buildet lykkes, men visningerne renderes ikke.

**Løsninger**:

* Tjek, at visningsfilerne findes i `src/views/`
* Verificer, at eksporterne matcher: `export function ExperienceView(props: ExperienceViewProps)`
* Sørg for, at visningsfilerne ender på `.tsx` eller `.jsx`

### Biblioteker virker ikke

**Problem**: Et tredjepartsbibliotek får appen til at crashe på mobil.

**Løsninger**:

* Verificer, at biblioteket understøtter React Native (ikke kun web)
* Brug de anbefalede versioner fra afsnittet [Brug af biblioteker](#using-third-party-libraries)
* Tjek, om biblioteket kræver native moduler (hvis det gør og ikke er blandt de anbefalede, understøttes det ikke)

### Platformspecifikke problemer

**Problem**: Appen virker på én platform, men ikke på en anden.

**Løsninger**:

* Brug `Platform.OS` til at registrere platformen og give fallbacks
* Test på alle platforme før forfremmelse til produktion
* Tjek, om du bruger platformspecifikke API'er forkert

***

## Næste trin

* [Opsæt godkendelse](https://docs.whop.com/da/developer/guides/authentication.md) til dine API-ruter
* [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md) med køb i appen
* [Brug webhooks](https://docs.whop.com/da/developer/guides/webhooks.md) til at håndtere events


## Related topics

- [App-visninger](https://docs.whop.com/da/developer/guides/app-views.md)
- [Byg Whop-apps](https://docs.whop.com/da/developer/apps/overview.md)
- [Iframe SDK](https://docs.whop.com/da/developer/guides/iframe.md)
