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

# Whop-apps bouwen met React Native

> Bouw een React Native-app die binnen de mobiele Whop-app op iOS en Android draait, en op het web.

Bouw native iOS-, Android- en webervaringen voor Whop met één React Native-codebase. Je apps draaien direct binnen de mobiele Whop-app en hebben toegang tot native platformfuncties.

## Hoe het werkt

Whop sluit React Native-apps in als experiences die op meerdere platforms draaien:

* **Mobiel (iOS/Android)**: apps draaien native binnen de mobiele Whop-app met volledige platformintegratie
* **Web**: apps draaien in de browser met automatische fallbacks voor platformspecifieke functies
* **Universele code**: één keer schrijven, overal deployen, met platformspecifieke optimalisaties

Je app ontvangt geauthenticeerde gebruikerscontext en kan API-aanroepen doen via de Whop SDK. Het buildsysteem regelt automatisch de platformspecifieke bundling met Metro voor mobiel en esbuild voor web.

***

## Aan de slag

### Systeemvereisten

Zorg er voordat je begint voor dat je systeem aan de volgende vereisten voldoet:

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

Voer `node -v` en `pnpm -v` uit om dit te controleren.

### Maak je app aan

Maak met de CLI een nieuwe Whop React Native-app aan:

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

Dit zet een nieuw project op met de volgende structuur:

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

### Omgevingsvariabelen configureren

Maak een `.env.local`-bestand aan in de hoofdmap:

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

Haal deze credentials op via het [Whop Developer-dashboard](https://whop.com/dashboard/developer):

1. Ga naar het Whop Developer-dashboard
2. Maak een nieuwe app aan of selecteer een bestaande
3. Kopieer de omgevingsvariabelen uit de app-instellingen

***

## Weergaven

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

Whop-apps gebruiken verschillende "views", afhankelijk van waar ze worden weergegeven. Elke view ontvangt geauthenticeerde context als props.

### Experience-view

De hoofdview voor experience-apps. Hier werken gebruikers met de content van je 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` - De experience-ID
* `companyId` - Het account dat eigenaar is van deze experience
* `currentUserId` - De geauthenticeerde gebruiker (of `null` als die niet is ingelogd)
* `path` - Navigatiepad als array (bijv. `["courses", "123"]`)
* `params` - Queryparameters als object

### Dashboard-view

Voor integraties in het accountdashboard waar verkopers hun bedrijf beheren.

```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` - De account-ID
* `currentUserId` - De geauthenticeerde gebruiker
* `path` - Navigatiepad als array
* `params` - Queryparameters

### Discover-view (optioneel)

Voor marketplace- en discovery-ervaringen waarin gebruikers door content bladeren.

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

***

## Gegevens ophalen

### De Whop SDK gebruiken

> [!WARNING]
>
> Dit voorbeeld gebruikt een verouderde SDK-interface. Het wordt bijgewerkt zodra de
> vervangende React Native SDK uitkomt.

De Whop SDK is direct beschikbaar voor het client-side ophalen van gegevens:

```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) is een goede keuze voor het ophalen van
> gegevens, omdat het caching, laadstatussen en opnieuw ophalen automatisch afhandelt.

> [!WARNING]
>
> Sommige SDK-bewerkingen zijn "server only" en moeten vanuit je API worden aangeroepen. Bekijk
> de [Quickstart](https://docs.whop.com/nl/developer/quickstart.md) om te zien welke methoden
> server-side uitvoering vereisen.

### Geauthenticeerde API-requests doen

Maak voor server-side bewerkingen API-routes aan en roep die aan vanuit je React Native-app:

**1. Stel je API-basis-URL in**

Configureer je API-origin in het [developer-dashboard](https://whop.com/dashboard/developer) onder **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. Maak een API-endpoint aan**

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

Zie de [Quickstart](https://docs.whop.com/nl/developer/quickstart.md) voor de SDK-configuratie.

**3. Roep aan vanuit React Native**

Gebruik de `apiOrigin` om geauthenticeerde requests te doen:

```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]
>
> Het is belangrijk om de `apiOrigin` te gebruiken voor geauthenticeerde requests. Zo gaan
> requests via de proxy van Whop met de juiste authenticatieheaders.

### Voorbeeld: toegang tot een experience controleren

```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]
>
> Dit server-side voorbeeld gebruikt een verouderde SDK-interface. Zie
> [Authenticatie](https://docs.whop.com/nl/developer/guides/authentication.md) voor de huidige
> server-side tokenverificatie met `@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

### Kleurthema's

React Native biedt een `useColorScheme`-hook om het kleurenschema van het apparaat te detecteren. Dit werkt automatisch in 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 }} />;
}
```

### Radix UI-kleuren gebruiken

Gebruik voor een uitgebreid kleursysteem met automatische donkere modus het `useColors`-hookpatroon met Radix UI-kleuren:

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

**Gebruik:**

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

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

***

## Navigatie

Gebruik de interne navigatie-API's om tussen schermen te navigeren en modals te tonen:

### Naar een nieuw scherm navigeren

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

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

Whop geeft `path` en `params` als props door aan je view-component.

### Teruggaan

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

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

### Een sheet of modal tonen

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

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

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

### Huidige route ophalen

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

***

## Platformspecifieke functies

### Navigatiebalk

Configureer de titel en beschrijving van de navigatiebalk:

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

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

### Schermoriëntatie

Bepaal de schermoriëntatie:

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

### Haptische feedback

Geef haptische feedback op mobiele apparaten:

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

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

**Beschikbare haptische types:**

* `"selection"` - Lichte selectiefeedback
* `"impactLight"` | `"impactMedium"` | `"impactHeavy"` - Impactfeedback
* `"notificationSuccess"` | `"notificationWarning"` | `"notificationError"` - Meldingsfeedback

### Lokale caching

Sla gegevens lokaal op het apparaat op:

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

### Details van de host-app

Haal informatie op over de Whop-app:

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

***

## In-app-aankopen

Accepteer betalingen direct in je 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);
	}
}
```

Zie de [documentatie over betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md) voor een volledige handleiding.

***

## Bibliotheken van derden gebruiken

De meeste React Native-bibliotheken werken direct. Dit zijn de aanbevolen versies voor veelgebruikte bibliotheken:

```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]
>
> Zorg er bij het toevoegen van nieuwe bibliotheken voor dat ze compatibel zijn met React Native.
> Sommige npm-pakketten zijn alleen voor het web en werken niet op mobiele platforms.

***

## Deployen

### Builden en deployen

Het commando `ship` buildt je app voor alle platforms en uploadt die als development-build:

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

Builden voor specifieke platforms:

```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]
>
> Het commando `ship` deployt als **development-build**, wat veilig is om uit te voeren op
> bestaande productie-apps. Het heeft geen invloed op je live gebruikers.

### Development- en productiebuilds

**Development-builds:**

* Gedeployd met `pnpm ship`
* Alleen zichtbaar wanneer je **Dev mode** inschakelt (telefoon schudden)
* Veilig om te testen zonder productiegebruikers te beïnvloeden
* Je kunt ze op elk moment deployen

**Productiebuilds:**

* Gepromoveerd vanuit development-builds via het dashboard
* Zichtbaar voor alle gebruikers
* Vereisen goedkeuring/review
* Test ze vóór promotie

### Een preview van je app bekijken

Bekijk na het deployen van een development-build een preview op je apparaat:

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

Dit genereert een QR-code waarmee je app wordt geïnstalleerd.

> [!WARNING]
>
> Om een preview van development-builds te bekijken, moet je **je telefoon schudden** om **Dev
> mode** in de Whop-app in te schakelen. Zo kun je niet-productiebuilds zien.

### Buildcommando's

Aanvullende commando's voor het beheren van builds:

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

### Naar productie promoveren

1. Deploy een development-build: `pnpm ship`
2. Test in **Dev mode** (schudden om in te schakelen)
3. Ga naar je [app-dashboard](https://whop.com/dashboard/developer)
4. Navigeer naar het tabblad Builds
5. Selecteer je development-build
6. Selecteer **Promote to Production**

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

Whop beoordeelt je app en deployt die na goedkeuring naar alle gebruikers.

### Terugdraaien

Vanuit het buildscherm kun je ook direct terugdraaien naar een eerdere productiebuild en die live zetten voor alle gebruikers op Whop.

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

***

## Referentie voor de command-line interface

De `@whop/react-native`-CLI biedt commando's voor het builden en deployen van je app:

### Commando's

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

### Buildproces

Wanneer je `pnpm ship` uitvoert, doet de CLI het volgende:

1. **Genereert entrypoints** - Maakt platformspecifieke entry-bestanden die je views registreren
2. **Bundelt code**:
   * **Mobiel (iOS/Android)**: gebruikt de Metro-bundler + Hermes-bytecodecompiler
   * **Web**: gebruikt esbuild met React Native Web-aliassen
3. **Verpakt assets** - Verzamelt en optimaliseert afbeeldingen en andere assets
4. **Uploadt naar Whop** - Maakt een development-build aan in je app-dashboard
5. **Genereert installatielink** - Levert een QR-code om te testen

### Buildoutput

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

***

## Probleemoplossing

### Development-build wordt niet weergegeven

**Probleem**: je hebt een development-build gedeployd, maar ziet die niet in de app.

**Oplossing**: schud je telefoon om **Dev mode** in te schakelen. Development-builds zijn alleen zichtbaar wanneer **Dev mode** actief is.

### Mislukte builds

**Probleem**: de build mislukt met Metro- of esbuild-fouten.

**Oplossingen**:

* Voer `pnpm clean` uit om de buildcache te wissen
* Controleer of je alle dependencies hebt geïnstalleerd: `pnpm install`
* Controleer de Node.js-versie: `node -v` (moet 22+ zijn)
* Controleer je views op syntaxfouten

### API-requests werken niet

**Probleem**: API-requests geven 401 of authenticatiefouten terug.

**Oplossingen**:

* Controleer of je `apiOrigin` gebruikt uit `__internal_execSync("getAppApiOrigin", {})`
* Controleer of `.env.local` `WHOP_API_KEY` instelt
* Bevestig dat je API-endpoint `whopSdk.verifyUserToken(request.headers)` aanroept
* Controleer of de basis-URL in het dashboard correct is ingesteld

### Views niet gevonden

**Probleem**: de build slaagt, maar views worden niet gerenderd.

**Oplossingen**:

* Controleer of view-bestanden bestaan in `src/views/`
* Controleer of de exports overeenkomen: `export function ExperienceView(props: ExperienceViewProps)`
* Zorg ervoor dat view-bestanden eindigen op `.tsx` of `.jsx`

### Bibliotheken werken niet

**Probleem**: een bibliotheek van derden veroorzaakt crashes op mobiel.

**Oplossingen**:

* Controleer of de bibliotheek React Native ondersteunt (niet alleen web)
* Gebruik de aanbevolen versies uit de sectie [Bibliotheken gebruiken](#using-third-party-libraries)
* Controleer of de bibliotheek native modules vereist (zo ja, en staat ze niet bij de aanbevolen bibliotheken, dan wordt ze niet ondersteund)

### Platformspecifieke problemen

**Probleem**: de app werkt op het ene platform, maar niet op het andere.

**Oplossingen**:

* Gebruik `Platform.OS` om het platform te detecteren en fallbacks te bieden
* Test op alle platforms voordat je naar productie promoveert
* Controleer of je platformspecifieke API's verkeerd gebruikt

***

## Volgende stappen

* [Stel authenticatie in](https://docs.whop.com/nl/developer/guides/authentication.md) voor je API-routes
* [Accepteer betalingen](https://docs.whop.com/nl/developer/guides/accept-payments.md) met in-app-aankopen
* [Gebruik webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md) om events af te handelen


## Related topics

- [Whop-apps bouwen](https://docs.whop.com/nl/developer/apps/overview.md)
- [App-weergaven](https://docs.whop.com/nl/developer/guides/app-views.md)
- [Gebruikers authenticeren in Whop-apps](https://docs.whop.com/nl/developer/guides/authentication.md)
