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

# Crea apps de Whop con React Native

> Crea una app de React Native que se ejecuta dentro de la app móvil de Whop en iOS y Android, y en la web.

Crea experiencias nativas de iOS, Android y web para Whop con una sola base de código de React Native. Tus apps se ejecutan directamente dentro de la app móvil de Whop y pueden acceder a funciones nativas de la plataforma.

## Cómo funciona

Whop integra las apps de React Native como experiencias que se ejecutan en varias plataformas:

* **Móvil (iOS/Android)**: las apps se ejecutan de forma nativa dentro de la app móvil de Whop con integración completa con la plataforma
* **Web**: las apps se ejecutan en el navegador con alternativas automáticas para las funciones específicas de cada plataforma
* **Código universal**: escribe una vez y despliega en todas partes con optimizaciones específicas para cada plataforma

Tu app recibe el contexto del usuario autenticado y puede hacer llamadas a la API a través del SDK de Whop. El sistema de compilación gestiona automáticamente el empaquetado específico de cada plataforma usando Metro para móvil y esbuild para web.

***

## Primeros pasos

### Requisitos del sistema

Antes de empezar, asegúrate de que tu sistema cumple los siguientes requisitos:

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

Para comprobarlo, ejecuta `node -v` y `pnpm -v`.

### Crea tu app

Crea una nueva app de Whop con React Native usando la CLI:

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

Esto configura un proyecto nuevo con la siguiente estructura:

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

### Configura las variables de entorno

Crea un archivo `.env.local` en el directorio raíz:

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

Obtén estas credenciales en el [panel de desarrollador de Whop](https://whop.com/dashboard/developer):

1. Ve al panel de desarrollador de Whop
2. Crea una app nueva o selecciona una existente
3. Copia las variables de entorno desde la configuración de la app

***

## Vistas

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

Las apps de Whop usan distintas "vistas" según dónde se muestren. Cada vista recibe el contexto autenticado como props.

### Vista de experiencia

La vista principal de las apps de experiencia. Aquí es donde los usuarios interactúan con el contenido de tu 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` - El ID de la experiencia
* `companyId` - La cuenta propietaria de esta experiencia
* `currentUserId` - El usuario autenticado (o `null` si no ha iniciado sesión)
* `path` - Ruta de navegación como array (p. ej., `["courses", "123"]`)
* `params` - Parámetros de consulta como objeto

### Vista de panel

Para integraciones en el panel de la cuenta, donde los vendedores gestionan su negocio.

```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` - El ID de la cuenta
* `currentUserId` - El usuario autenticado
* `path` - Ruta de navegación como array
* `params` - Parámetros de consulta

### Vista de descubrimiento (opcional)

Para experiencias de marketplace/descubrimiento en las que los usuarios exploran contenido.

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

***

## Obtención de datos

### Uso del SDK de Whop

> [!WARNING]
>
> Este ejemplo usa una interfaz del SDK obsoleta. Se actualizará cuando se publique
> el SDK de React Native que la reemplaza.

El SDK de Whop está disponible de serie para obtener datos en el cliente:

```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) es una buena opción para obtener
> datos porque gestiona automáticamente la caché, los estados de carga y las nuevas solicitudes.

> [!WARNING]
>
> Algunas operaciones del SDK son "solo de servidor" y deben llamarse desde tu API. Consulta
> el [inicio rápido](https://docs.whop.com/es/developer/quickstart.md) para saber qué métodos requieren
> ejecución en el servidor.

### Solicitudes autenticadas a la API

Para operaciones en el servidor, crea rutas de API y llámalas desde tu app de React Native:

**1. Configura la URL base de tu API**

Configura el origen de tu API en el [panel de desarrollador](https://whop.com/dashboard/developer), en **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. Crea un endpoint de 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 });
}
```

Consulta el [inicio rápido](https://docs.whop.com/es/developer/quickstart.md) para configurar el SDK.

**3. Llámalo desde React Native**

Usa `apiOrigin` para hacer solicitudes autenticadas:

```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]
>
> Es importante usar `apiOrigin` para las solicitudes autenticadas. Así te aseguras de que
> las solicitudes pasen por el proxy de Whop con los encabezados de autenticación adecuados.

### Ejemplo: comprobar el acceso a una experiencia

```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]
>
> Este ejemplo de servidor usa una interfaz del SDK obsoleta. Para la verificación
> actual de tokens en el servidor con `@whop/sdk`, consulta
> [Autenticación](https://docs.whop.com/es/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 });
}
```

***

## Estilos

### Temas de color

React Native proporciona el hook `useColorScheme` para detectar el esquema de color del dispositivo. Funciona automáticamente en las apps de 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 }} />;
}
```

### Uso de los colores de Radix UI

Para un sistema de color completo con modo oscuro automático, usa el patrón del hook `useColors` con los colores de 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),
	};
}
```

**Uso:**

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

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

***

## Navegación

Usa las APIs de navegación internas para moverte entre pantallas y mostrar modales:

### Navega a una pantalla nueva

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

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

Whop pasa `path` y `params` como props a tu componente de vista.

### Volver atrás

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

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

### Muestra una hoja o un 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", {});
}
```

### Obtén la ruta actual

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

***

## Funciones específicas de la plataforma

### Barra de navegación

Configura el título y la descripción de la barra de navegación:

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

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

### Orientación de la pantalla

Controla la orientación de la pantalla:

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

### Respuesta háptica

Proporciona respuesta háptica en dispositivos móviles:

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

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

**Tipos de respuesta háptica disponibles:**

* `"selection"` - Respuesta ligera de selección
* `"impactLight"` | `"impactMedium"` | `"impactHeavy"` - Respuesta de impacto
* `"notificationSuccess"` | `"notificationWarning"` | `"notificationError"` - Respuesta de notificación

### Caché local

Guarda datos localmente en el dispositivo:

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

### Detalles de la app anfitriona

Obtén información sobre la app de 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"
```

***

## Compras dentro de la app

Acepta pagos directamente dentro de tu 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);
	}
}
```

Para ver una guía completa sobre cómo aceptar pagos, consulta la [documentación de Acepta pagos](https://docs.whop.com/es/developer/guides/accept-payments.md).

***

## Uso de bibliotecas de terceros

La mayoría de las bibliotecas de React Native funcionan de serie. Estas son las versiones recomendadas de las bibliotecas más comunes:

```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]
>
> Al añadir bibliotecas nuevas, asegúrate de que sean compatibles con React Native.
> Algunos paquetes de npm son solo para web y no funcionarán en plataformas móviles.

***

## Despliegue

### Compila y despliega

El comando `ship` compila tu app para todas las plataformas y la sube como build de desarrollo:

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

Compila para plataformas específicas:

```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]
>
> El comando `ship` despliega como **build de desarrollo**, que es seguro ejecutar en
> apps de producción existentes. No afectará a tus usuarios activos.

### Builds de desarrollo y producción

**Builds de desarrollo:**

* Se despliegan con `pnpm ship`
* Solo son visibles cuando activas el **Dev mode** (agita el teléfono)
* Se pueden probar con seguridad sin afectar a los usuarios de producción
* Puedes desplegarlas en cualquier momento

**Builds de producción:**

* Se promueven desde builds de desarrollo a través del panel
* Visibles para todos los usuarios
* Requieren aprobación/revisión
* Pruébalas antes de promoverlas

### Previsualiza tu app

Después de desplegar una build de desarrollo, previsualízala en tu dispositivo:

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

Esto genera un código QR que instala tu app.

> [!WARNING]
>
> Para previsualizar builds de desarrollo, debes **agitar el teléfono** para activar el **Dev
> mode** en la app de Whop. Esto te permite ver builds que no son de producción.

### Comandos de compilación

Comandos adicionales para gestionar builds:

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

### Promoción a producción

1. Despliega una build de desarrollo: `pnpm ship`
2. Prueba en **Dev mode** (agita el teléfono para activarlo)
3. Ve al [panel de tu app](https://whop.com/dashboard/developer)
4. Ve a la pestaña Builds
5. Selecciona tu build de desarrollo
6. Selecciona **Promote to Production**

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

Whop revisa tu app y la despliega para todos los usuarios tras la aprobación.

### Reversión

Desde la pantalla de builds también puedes volver al instante a una build de producción anterior y publicarla para todos los usuarios de Whop.

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

***

## Referencia de la interfaz de línea de comandos

La CLI de `@whop/react-native` ofrece comandos para compilar y desplegar tu app:

### Comandos

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

### Proceso de compilación

Cuando ejecutas `pnpm ship`, la CLI:

1. **Genera los puntos de entrada**: crea archivos de entrada específicos de cada plataforma que registran tus vistas
2. **Empaqueta el código**:
   * **Móvil (iOS/Android)**: usa el bundler Metro + el compilador de bytecode Hermes
   * **Web**: usa esbuild con alias de React Native Web
3. **Empaqueta los recursos**: recopila y optimiza imágenes y otros recursos
4. **Sube a Whop**: crea una build de desarrollo en el panel de tu app
5. **Genera el enlace de instalación**: proporciona un código QR para hacer pruebas

### Resultado de la compilación

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

***

## Solución de problemas

### La build de desarrollo no aparece

**Problema**: desplegaste una build de desarrollo pero no la ves en la app.

**Solución**: agita el teléfono para activar el **Dev mode**. Las builds de desarrollo solo son visibles cuando el **Dev mode** está activo.

### Fallos de compilación

**Problema**: la compilación falla con errores de Metro o esbuild.

**Soluciones**:

* Ejecuta `pnpm clean` para borrar la caché de compilación
* Comprueba que instalaste todas las dependencias: `pnpm install`
* Verifica la versión de Node.js: `node -v` (debe ser 22+)
* Busca errores de sintaxis en tus vistas

### Las solicitudes a la interfaz de programación de aplicaciones no funcionan

**Problema**: las solicitudes a la API devuelven 401 o errores de autenticación.

**Soluciones**:

* Verifica que estás usando `apiOrigin` de `__internal_execSync("getAppApiOrigin", {})`
* Comprueba que `.env.local` define `WHOP_API_KEY`
* Confirma que tu endpoint de API llama a `whopSdk.verifyUserToken(request.headers)`
* Verifica que la URL base esté configurada correctamente en el panel

### No se encuentran las vistas

**Problema**: la compilación se completa pero las vistas no se renderizan.

**Soluciones**:

* Comprueba que los archivos de vista existen en `src/views/`
* Verifica que las exportaciones coincidan: `export function ExperienceView(props: ExperienceViewProps)`
* Asegúrate de que los archivos de vista terminen en `.tsx` o `.jsx`

### Las bibliotecas no funcionan

**Problema**: una biblioteca de terceros provoca cierres inesperados en móvil.

**Soluciones**:

* Verifica que la biblioteca sea compatible con React Native (no solo con web)
* Usa las versiones recomendadas de la sección [Uso de bibliotecas](#using-third-party-libraries)
* Comprueba si la biblioteca requiere módulos nativos (si es así y no está entre las recomendadas, no es compatible)

### Problemas específicos de la plataforma

**Problema**: la app funciona en una plataforma pero no en otra.

**Soluciones**:

* Usa `Platform.OS` para detectar la plataforma y ofrecer alternativas
* Prueba en todas las plataformas antes de promover a producción
* Comprueba si estás usando incorrectamente APIs específicas de una plataforma

***

## Próximos pasos

* [Configura la autenticación](https://docs.whop.com/es/developer/guides/authentication.md) para tus rutas de API
* [Acepta pagos](https://docs.whop.com/es/developer/guides/accept-payments.md) con compras dentro de la app
* [Usa webhooks](https://docs.whop.com/es/developer/guides/webhooks.md) para gestionar eventos


## Related topics

- [Crea apps de Whop](https://docs.whop.com/es/developer/apps/overview.md)
- [Crea un sitio web con la CLI](https://docs.whop.com/es/developer/websites/quickstart.md)
- [Vistas de la app](https://docs.whop.com/es/developer/guides/app-views.md)
