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

# Créer des apps Whop avec React Native

> Créez une app React Native qui s'exécute dans l'app mobile Whop sur iOS et Android, ainsi que sur le web.

Créez des expériences natives iOS, Android et web pour Whop à partir d'une seule base de code React Native. Vos apps s'exécutent directement dans l'app mobile Whop et peuvent accéder aux fonctionnalités natives de la plateforme.

## Fonctionnement

Whop intègre les apps React Native sous forme d'expériences qui s'exécutent sur plusieurs plateformes :

* **Mobile (iOS/Android)** : les apps s'exécutent en natif dans l'app mobile Whop avec une intégration complète à la plateforme
* **Web** : les apps s'exécutent dans le navigateur avec des solutions de repli automatiques pour les fonctionnalités propres à chaque plateforme
* **Code universel** : écrivez une fois, déployez partout, avec des optimisations propres à chaque plateforme

Votre app reçoit le contexte de l'utilisateur authentifié et peut effectuer des appels API via le SDK Whop. Le système de build gère automatiquement le bundling propre à chaque plateforme, avec Metro pour le mobile et esbuild pour le web.

***

## Premiers pas

### Configuration requise

Avant de commencer, assurez-vous que votre système respecte les exigences suivantes :

* [Node.js 22](https://nodejs.org/) ou version ultérieure
* [pnpm 9.15](https://pnpm.io/) ou version ultérieure

Pour vérifier, exécutez `node -v` et `pnpm -v`.

### Créer votre app

Créez une nouvelle app Whop React Native avec la CLI :

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

Cette commande crée un nouveau projet avec la structure suivante :

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

### Configurer les variables d'environnement

Créez un fichier `.env.local` à la racine du projet :

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

Obtenez ces identifiants depuis le [tableau de bord développeur Whop](https://whop.com/dashboard/developer) :

1. Accédez au tableau de bord développeur Whop
2. Créez une nouvelle app ou sélectionnez-en une existante
3. Copiez les variables d'environnement depuis les paramètres de l'app

***

## Vues

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

Les apps Whop utilisent différentes « vues » selon l'endroit où elles sont affichées. Chaque vue reçoit le contexte authentifié sous forme de props.

### Vue d'expérience

La vue principale des apps d'expérience. C'est là que les utilisateurs interagissent avec le contenu de votre 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` - L'ID de l'expérience
* `companyId` - Le compte propriétaire de cette expérience
* `currentUserId` - L'utilisateur authentifié (ou `null` s'il n'est pas connecté)
* `path` - Chemin de navigation sous forme de tableau (p. ex. `["courses", "123"]`)
* `params` - Paramètres de requête sous forme d'objet

### Vue du tableau de bord

Pour les intégrations au tableau de bord du compte, où les vendeurs gèrent leur entreprise.

```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` - L'ID du compte
* `currentUserId` - L'utilisateur authentifié
* `path` - Chemin de navigation sous forme de tableau
* `params` - Paramètres de requête

### Vue Discover (facultative)

Pour les expériences de marketplace/découverte, où les utilisateurs parcourent du contenu.

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

***

## Récupérer des données

### Utiliser le SDK Whop

> [!WARNING]
>
> Cet exemple utilise une interface SDK obsolète. Il sera mis à jour à la sortie
> du nouveau SDK React Native.

Le SDK Whop est disponible d'emblée pour récupérer des données côté client :

```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) est un bon choix pour récupérer
> des données, car il gère automatiquement la mise en cache, les états de chargement et les nouvelles récupérations.

> [!WARNING]
>
> Certaines opérations du SDK sont réservées au serveur (« server only ») et doivent être appelées depuis votre API. Consultez
> le [guide de démarrage rapide](https://docs.whop.com/fr/developer/quickstart.md) pour savoir quelles méthodes nécessitent
> une exécution côté serveur.

### Effectuer des requêtes API authentifiées

Pour les opérations côté serveur, créez des routes API et appelez-les depuis votre app React Native :

**1. Définissez l'URL de base de votre API**

Configurez l'origine de votre API dans le [tableau de bord développeur](https://whop.com/dashboard/developer) sous **Base URL**.

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

**2. Créez un endpoint API**

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

Consultez le [guide de démarrage rapide](https://docs.whop.com/fr/developer/quickstart.md) pour la configuration du SDK.

**3. Appelez-le depuis React Native**

Utilisez `apiOrigin` pour effectuer des requêtes authentifiées :

```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]
>
> Il est important d'utiliser `apiOrigin` pour les requêtes authentifiées. Cela garantit que
> les requêtes passent par le proxy de Whop avec les en-têtes d'authentification appropriés.

### Exemple : vérifier l'accès à une expérience

```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]
>
> Cet exemple côté serveur utilise une interface SDK obsolète. Pour la vérification actuelle
> des jetons côté serveur avec `@whop/sdk`, consultez
> [Authentification](https://docs.whop.com/fr/developer/guides/authentication.md).

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

***

## Style

### Thèmes de couleur

React Native fournit un hook `useColorScheme` pour détecter le thème de couleur de l'appareil. Il fonctionne automatiquement dans les apps Whop :

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

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

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

### Utiliser les couleurs Radix UI

Pour un système de couleurs complet avec mode sombre automatique, utilisez le modèle de hook `useColors` avec les couleurs Radix UI :

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

**Utilisation :**

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

Utilisez les API de navigation internes pour naviguer entre les écrans et afficher des modales :

### Naviguer vers un nouvel écran

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

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

Whop transmet `path` et `params` sous forme de props à votre composant de vue.

### Revenir en arrière

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

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

### Afficher une feuille ou une modale

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

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

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

### Obtenir la route actuelle

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

***

## Fonctionnalités propres à chaque plateforme

### Barre de navigation

Configurez le titre et la description de la barre de navigation :

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

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

### Orientation de l'écran

Contrôlez l'orientation de l'écran :

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

### Retour haptique

Fournissez un retour haptique sur les appareils mobiles :

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

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

**Types de retour haptique disponibles :**

* `"selection"` - Retour léger de sélection
* `"impactLight"` | `"impactMedium"` | `"impactHeavy"` - Retour d'impact
* `"notificationSuccess"` | `"notificationWarning"` | `"notificationError"` - Retour de notification

### Cache local

Stockez des données localement sur l'appareil :

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

### Détails de l'app hôte

Obtenez des informations sur l'app Whop :

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

***

## Achats in-app

Acceptez des paiements directement dans votre 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);
	}
}
```

Pour un guide complet sur l'acceptation des paiements, consultez la [documentation Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md).

***

## Utiliser des bibliothèques tierces

La plupart des bibliothèques React Native fonctionnent d'emblée. Voici les versions recommandées des bibliothèques courantes :

```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]
>
> Lorsque vous ajoutez de nouvelles bibliothèques, assurez-vous qu'elles sont compatibles avec React Native.
> Certains paquets npm sont réservés au web et ne fonctionnent pas sur les plateformes mobiles.

***

## Déploiement

### Build et déploiement

La commande `ship` compile votre app pour toutes les plateformes et la téléverse en tant que build de développement :

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

Compiler pour des plateformes spécifiques :

```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]
>
> La commande `ship` déploie un **build de développement**, que vous pouvez exécuter sans risque sur
> des apps déjà en production. Il n'affecte pas vos utilisateurs actuels.

### Builds de développement et de production

**Builds de développement :**

* Déployés avec `pnpm ship`
* Visibles uniquement lorsque vous activez le **Dev mode** (secouez le téléphone)
* Testables sans risque, sans affecter les utilisateurs en production
* Déployables à tout moment

**Builds de production :**

* Promus à partir des builds de développement via le tableau de bord
* Visibles par tous les utilisateurs
* Nécessitent une approbation/revue
* À tester avant la promotion

### Prévisualiser votre app

Après avoir déployé un build de développement, prévisualisez-le sur votre appareil :

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

Cette commande génère un QR code qui installe votre app.

> [!WARNING]
>
> Pour prévisualiser les builds de développement, vous devez **secouer votre téléphone** pour activer le **Dev
> mode** dans l'app Whop. Cela vous permet de voir les builds hors production.

### Commandes de build

Commandes supplémentaires pour gérer les builds :

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

### Promouvoir en production

1. Déployez un build de développement : `pnpm ship`
2. Testez en **Dev mode** (secouez pour l'activer)
3. Accédez au [tableau de bord de votre app](https://whop.com/dashboard/developer)
4. Ouvrez l'onglet Builds
5. Sélectionnez votre build de développement
6. Sélectionnez **Promote to Production**

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

Whop examine votre app et la déploie auprès de tous les utilisateurs après approbation.

### Retour arrière

Depuis l'écran des builds, vous pouvez aussi revenir instantanément à un build de production précédent et le mettre en ligne pour tous les utilisateurs de Whop.

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

***

## Référence de l'interface en ligne de commande

La CLI `@whop/react-native` fournit des commandes pour compiler et déployer votre app :

### Commandes

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

### Processus de build

Lorsque vous exécutez `pnpm ship`, la CLI :

1. **Génère les points d'entrée** - Crée des fichiers d'entrée propres à chaque plateforme qui enregistrent vos vues
2. **Bundle le code** :
   * **Mobile (iOS/Android)** : utilise le bundler Metro + le compilateur de bytecode Hermes
   * **Web** : utilise esbuild avec les alias React Native Web
3. **Empaquette les ressources** - Collecte et optimise les images et autres ressources
4. **Téléverse sur Whop** - Crée un build de développement dans le tableau de bord de votre app
5. **Génère un lien d'installation** - Fournit un QR code pour les tests

### Sortie du build

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

***

## Dépannage

### Le build de développement ne s'affiche pas

**Problème** : vous avez déployé un build de développement mais vous ne le voyez pas dans l'app.

**Solution** : secouez votre téléphone pour activer le **Dev mode**. Les builds de développement ne sont visibles que lorsque le **Dev mode** est actif.

### Échecs de build

**Problème** : le build échoue avec des erreurs Metro ou esbuild.

**Solutions** :

* Exécutez `pnpm clean` pour vider le cache de build
* Vérifiez que vous avez installé toutes les dépendances : `pnpm install`
* Vérifiez la version de Node.js : `node -v` (doit être 22+)
* Recherchez des erreurs de syntaxe dans vos vues

### Les requêtes vers l'interface de programmation ne fonctionnent pas

**Problème** : les requêtes API renvoient une erreur 401 ou des erreurs d'authentification.

**Solutions** :

* Vérifiez que vous utilisez `apiOrigin` issu de `__internal_execSync("getAppApiOrigin", {})`
* Vérifiez que `.env.local` définit `WHOP_API_KEY`
* Confirmez que votre endpoint API appelle `whopSdk.verifyUserToken(request.headers)`
* Vérifiez que l'URL de base est correctement définie dans le tableau de bord

### Vues introuvables

**Problème** : le build réussit mais les vues ne s'affichent pas.

**Solutions** :

* Vérifiez que les fichiers de vue existent dans `src/views/`
* Vérifiez que les exports correspondent : `export function ExperienceView(props: ExperienceViewProps)`
* Assurez-vous que les fichiers de vue se terminent par `.tsx` ou `.jsx`

### Les bibliothèques ne fonctionnent pas

**Problème** : une bibliothèque tierce provoque des plantages sur mobile.

**Solutions** :

* Vérifiez que la bibliothèque prend en charge React Native (pas seulement le web)
* Utilisez les versions recommandées de la section [Utiliser des bibliothèques](#using-third-party-libraries)
* Vérifiez si la bibliothèque nécessite des modules natifs (si c'est le cas et qu'elle ne figure pas dans la liste recommandée, elle n'est pas prise en charge)

### Problèmes propres à une plateforme

**Problème** : l'app fonctionne sur une plateforme mais pas sur une autre.

**Solutions** :

* Utilisez `Platform.OS` pour détecter la plateforme et prévoir des solutions de repli
* Testez sur toutes les plateformes avant de promouvoir en production
* Vérifiez que vous n'utilisez pas incorrectement des API propres à une plateforme

***

## Étapes suivantes

* [Configurez l'authentification](https://docs.whop.com/fr/developer/guides/authentication.md) pour vos routes API
* [Acceptez des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md) avec les achats in-app
* [Utilisez les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) pour gérer les événements


## Related topics

- [Créer un site web avec la CLI](https://docs.whop.com/fr/developer/websites/quickstart.md)
- [Vues d'application](https://docs.whop.com/fr/developer/guides/app-views.md)
- [Apparence](https://docs.whop.com/fr/elements/latest/appearance.md)
