Cómo implementar Stripe Payment Links en apps de Capacitor tras las nuevas directrices de Apple

A partir del 1 de mayo de 2025, Apple ha implementado cambios significativos en sus App Store Review Guidelines tras el fallo judicial en el caso Epic v. Apple. Estos cambios permiten específicamente a los desarrolladores de apps en Estados Unidos enlazar a métodos de pago externos para bienes y servicios digitales, ofreciendo alternativas al sistema de compras in-app de Apple.

La batalla épica que cambió los pagos móviles para siempre

El camino hasta este momento ha sido largo y polémico. Todo empezó en agosto de 2020, cuando Epic Games, creadora del popular Fortnite, violó deliberadamente las directrices de la App Store de Apple al implementar una opción de pago directo para evitar la comisión del 30% de Apple. Apple eliminó Fortnite de la App Store de inmediato, y Epic respondió con una demanda para desafiar el control de Apple sobre la distribución de apps en iOS y los pagos in-app.

Tras años de batallas legales, apelaciones y contraapelaciones, los tribunales finalmente dictaminaron que Apple debe permitir que los desarrolladores dirijan a los usuarios a métodos de pago alternativos fuera de sus apps. Esta decisión cambia fundamentalmente la economía del ecosistema de la App Store, que ha operado bajo el mismo modelo financiero básico desde su creación en 2008.

El fallo final: no hay más apelaciones

Lo que hace que este fallo sea especialmente significativo es que es definitivo y no puede ser apelado. El Tribunal Supremo rechazó la apelación de Apple a principios de 2025, consolidando la decisión del tribunal inferior como ley vigente. Esto significa que los desarrolladores pueden implementar métodos de pago externos con la confianza de que Apple no podrá revertir esta decisión mediante nuevos desafíos legales.

Trato igualitario garantizado por ley

Lo más importante es que el fallo establece explícitamente que Apple no puede discriminar a las apps que usan métodos de pago externos. El tribunal prohibió específicamente que Apple:

Cobrar comisiones adicionales o imponer requisitos extra a las apps que usan métodos de pago externos
Dar prioridad en los resultados de búsqueda o destacar aplicaciones que utilicen exclusivamente el sistema de IAP de Apple
Usar medidas técnicas para que las experiencias de pago externas sean inferiores al sistema de Apple
Imponer requisitos de divulgación excesivos más allá de la información básica del consumidor

Estas protecciones explícitas permiten a los desarrolladores implementar Stripe u otros proveedores de pago externos sin temor a represalias o discriminación sutiles por parte de Apple. El terreno de juego se ha nivelado legalmente, y Apple debe tratar a todas las apps por igual, sin importar qué método de pago elijan.

El fallo representa uno de los mayores desafíos al enfoque de jardín amurallado de Apple y marca un cambio clave en cómo puede funcionar la monetización de apps móviles. Para los desarrolladores que llevan tiempo quejándose de la comisión del 30% de Apple (reducida al 15% para pequeñas empresas), este fallo abre un camino hacia mayores márgenes de beneficio y más control sobre la experiencia del cliente.

Beneficios financieros de usar Stripe frente a las compras in-app de Apple

Las implicaciones financieras de este cambio son considerables para los desarrolladores:

Menores comisiones de procesamiento de pagos: Apple suele cobrar una comisión del 30% en las compras in-app (15% para pequeñas empresas), mientras que la comisión de Stripe es de solo un 2,9% + 0,30 $ por transacción. Esta diferencia puede aumentar significativamente tus márgenes de ingresos.
Pagos más rápidos: Con Apple, sueles esperar entre 45 y 90 días para recibir tus fondos. Stripe, en cambio, deposita los pagos en tu cuenta bancaria en 2 o 3 días hábiles.
Proceso de reembolso simplificado: Gestiona los reembolsos directamente desde el dashboard de Stripe en lugar de usar el complejo sistema de Apple.

Estos ahorros de costes y la mejora del flujo de caja pueden cambiarlo todo, especialmente para desarrolladores y empresas más pequeñas.

En este artículo, exploraremos cómo implementar Stripe Payment Links en tu app Capacitor para aprovechar estas nuevas reglas, asegurando el cumplimiento de las directrices actualizadas de Apple.

Esta implementación se basa en la documentación oficial de Stripe para Payment Links, adaptada específicamente para apps Capacitor.

Entendiendo las nuevas directrices

Las App Store Review Guidelines actualizadas ahora permiten a los desarrolladores dirigir a los usuarios a sitios web externos para procesar pagos, específicamente para bienes digitales y suscripciones. Este cambio solo aplica actualmente a apps distribuidas en la App Store de Estados Unidos.

Puntos clave a tener en cuenta:

Ya puedes vincular opciones de pago externas para productos digitales en tu app
Esto solo aplica para apps en la App Store de EE. UU.
Debes seguir cumpliendo con los requisitos de divulgación de Apple
Seguirás siendo responsable de todo el soporte al cliente y reembolsos

Configuración de Stripe Payment Links en tu app Capacitor

Veamos la implementación técnica:

Paso 1: Crea un Payment Link en el Stripe Dashboard

Primero, crea un link de pago en tu Stripe Dashboard:

Ve a la sección Payment Links en tu Stripe Dashboard
Haz clic en “+ New” para crear un nuevo link de pago
Define los detalles de tu producto o suscripción
En la configuración “After payment”, selecciona “Don’t show confirmation page”
Configura un universal link como tu URL de éxito (lo haremos más tarde)
Haz clic en “Create Link” para generar tu enlace de pago

Paso 2: Configura los Universal Links en tu app Capacitor

Para redirigir a los usuarios de vuelta a tu app tras el pago, configura los universal links:

Crea un apple-app-site-association archivo en tu dominio:

{
  "applinks": {
    "apps": [],
    "details": [
      {
        "appIDs": ["YOURTEAMID.com.yourdomain.yourapp"],
        "components": [
          {
            "/": "/checkout_redirect*",
            "comment": "Matches any URL whose path starts with /checkout_redirect"
          }
        ]
      }
    ]
  }
}

Aloja este archivo en https://yourdomain.com/.well-known/apple-app-site-association
Asegúrate de que se sirva con el MIME type correcto application/json
Configura tu app Capacitor para manejar universal links añadiendo el entitlement adecuado. Primero, en tu capacitor.config.ts:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  // Your existing app configuration (appId, appName, etc.)
  plugins: {
    Geolocation: {
      // Request precise location access on iOS
      iosLocationAccuracy: 'reduced'
    }
  }
};

export default config;

Añade el entitlement Associated Domains a tu proyecto de Xcode:
- Abre tu proyecto de Xcode
- Selecciona el target de tu app
- Ve a “Signing & Capabilities”
- Haz clic en “+ Capability” y selecciona “Associated Domains”
- Añadir applinks:yourdomain.com

Paso 3: Crea una página de fallback

Crea una página de fallback en la URL de redirección para manejar los casos en que la app no esté instalada:

<!DOCTYPE html>
<html>
<head>
  <title>Redirecting...</title>
  <meta http-equiv="refresh" content="0;url=https://yourdomain.com/app-download">
</head>
<body>
  <p>Redirecting to download page...</p>
</body>
</html>

Paso 4: Implementa el botón de pago en tu app Capacitor

Ahora, añade el botón de pago a tu app:

import { Capacitor } from '@capacitor/core';

export async function openPaymentLink(userEmail, userId) {
  // Use your actual Stripe payment link
  const baseUrl = 'https://buy.stripe.com/your_payment_link';
  
  // Add URL parameters to customize the experience
  const params = new URLSearchParams({
    prefilled_email: encodeURIComponent(userEmail),
    client_reference_id: userId
  });

  const fullUrl = `${baseUrl}?${params.toString()}`;
  
  // Simple window.open works in both web and Capacitor
  // Using _blank opens in Safari on iOS which is important for users with saved Stripe Link credentials
  window.open(fullUrl, '_blank');
}

Por qué Safari es importante: Abrir el enlace de pago en Safari (vía window.open) en lugar de un navegador in-app es beneficioso, ya que los usuarios que hayan guardado su información de pago con Stripe Link tendrán sus credenciales disponibles automáticamente. Esto crea un checkout más fluido donde los usuarios no tendrán que volver a introducir su tarjeta, reduciendo significativamente la fricción y las tasas de abandono.

Paso 5: Gestiona los Universal Links en tu app

Configura tu app para gestionar los universal links cuando los usuarios sean redirigidos de vuelta:

Primero, instala el plugin App:

npm install @capacitor/app

Registra el plugin App en tu app:

import { App } from '@capacitor/app';

// In your initialization code
App.addListener('appUrlOpen', (event) => {
  // Example URL: https://yourdomain.com/checkout_redirect?session_id=cs_test_...
  const url = new URL(event.url);
  
  if (url.pathname.startsWith('/checkout_redirect')) {
    // Extract any parameters you need
    const params = new URLSearchParams(url.search);
    const sessionId = params.get('session_id');
    
    // Handle successful payment
    if (sessionId) {
      // Verify the payment on your server if needed
      verifyPayment(sessionId);
      
      // Update UI to reflect successful purchase
      updatePurchaseStatus(true);
    }
  }
});

async function verifyPayment(sessionId) {
  // Call your backend to verify the payment
  // This is optional if you're relying on webhooks
}

function updatePurchaseStatus(success) {
  // Update your app UI to reflect purchase status
}

Paso 6: Configura el webhook para el cumplimiento de pedidos

Por último, configura un webhook en tu servidor para gestionar los pagos exitosos:

// Using Express.js as an example
const express = require('express');
const stripe = require('stripe')('sk_test_your_stripe_secret_key');
const app = express();

// Use raw body parser for webhook signature verification
app.post('/webhook', express.raw({type: 'application/json'}), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  const webhookSecret = 'whsec_your_webhook_secret';
  
  let event;
  
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
  } catch (err) {
    console.log(`Webhook Error: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }
  
  // Handle the checkout.session.completed event
  if (event.type === 'checkout.session.completed') {
    const session = event.data.object;
    
    // Retrieve client_reference_id (your user ID)
    const userId = session.client_reference_id;
    
    // Grant access to the purchased content
    await grantAccess(userId, session.id);
  }
  
  res.status(200).send();
});

async function grantAccess(userId, sessionId) {
  // Your logic to grant access to the purchased content
  // This could be updating a database, sending a notification, etc.
}

app.listen(3000, () => console.log('Webhook server running on port 3000'));

Compatibilidad con Android

Seamos claros: el fallo de Epic contra Apple ha cambiado fundamentalmente el panorama de los pagos móviles. No solo impacta directamente a las apps de iOS, sino que también refuerza la posición de los desarrolladores de Android que han estado usando métodos de pago externos.

Los desarrolladores de Android ahora pueden implementar soluciones de pago externas con total confianza. El precedente establecido por el fallo de Apple protege eficazmente a los desarrolladores de todas las plataformas frente a posibles restricciones futuras. Esta decisión judicial ha validado lo que muchos desarrolladores de Android han estado haciendo durante años: ofrecer opciones de pago alternativas con comisiones más bajas.

La Play Store de Google siempre ha sido menos restrictiva con los métodos de pago externos que Apple, y ahora, con el precedente legal establecido, prácticamente no hay riesgo en implementar Stripe u otros proveedores de pago externos en tus apps de Android. Puedes avanzar con estas implementaciones sabiendo que tienes una base legal sólida.

La implementación que hemos cubierto para iOS funciona de forma casi idéntica en dispositivos Android. Dado que la Google Play Store no tiene las mismas restricciones sobre métodos de pago externos, puedes usar exactamente el mismo enfoque de Stripe Payment Links sin necesidad de diálogos de divulgación especiales.

Para gestionar el deep linking (equivalente a los universal links en iOS), necesitarás:

Configura los App Links en tu AndroidManifest.xml para gestionar la URL de redirección
Crea un .well-known/assetlinks.json archivo en tu dominio con los detalles de tu app
Usa la misma appUrlOpen lógica del listener para procesar pagos exitosos

La ventaja de Capacitor es que, tras implementar las configuraciones específicas de cada plataforma, el flujo de pago real code sigue siendo el mismo en ambas.

Crear una UI de pago

Aquí tienes un ejemplo de un componente de botón de pago en Vue que puedes añadir a tu app de Capacitor:

<template>
  <div class="payment-container">
    <div class="pricing-card">
      <h2 class="mb-4 text-xl font-bold">{{ product.name }}</h2>
      <p class="mb-6 text-gray-600">{{ product.description }}</p>
      <div class="mb-6 price-tag">
        <span class="text-2xl font-bold">${{ product.price }}</span>
        <span v-if="product.isSubscription" class="text-sm text-gray-500">/month</span>
      </div>
      <button 
        @click="handlePayment" 
        class="py-3 w-full font-medium text-white bg-indigo-600 rounded-lg transition-colors hover:bg-indigo-700"
      >
        Purchase Now
      </button>
    </div>
  </div>
</template>

<script setup>
import { ref } from 'vue';
import { Dialog } from '@capacitor/dialog';

const props = defineProps({
  product: {
    type: Object,
    required: true
  },
  userEmail: {
    type: String,
    default: ''
  },
  userId: {
    type: String,
    required: true
  }
});

const isLoading = ref(false);

async function showExternalPaymentDisclosure() {
  const { value } = await Dialog.confirm({
    title: 'Leaving App for Payment',
    message: 'You are about to leave this app to make a payment. Apple is not responsible for the privacy or security of payments that are not made through the App Store. All payment-related issues, including refunds, must be handled by our support team.',
    okButtonTitle: 'Continue',
    cancelButtonTitle: 'Cancel'
  });
  
  return value;
}

async function openPaymentLink() {
  // Use your actual Stripe payment link
  const baseUrl = 'https://buy.stripe.com/your_payment_link';
  
  // Add URL parameters to customize the experience
  const params = new URLSearchParams({
    prefilled_email: encodeURIComponent(props.userEmail),
    client_reference_id: props.userId
  });

  const fullUrl = `${baseUrl}?${params.toString()}`;
  
  // Simple window.open works in both web and Capacitor
  // Using _blank opens in Safari on iOS which is important for users with saved Stripe Link credentials
  window.open(fullUrl, '_blank');
}

async function handlePayment() {
  isLoading.value = true;
  try {
    // Only show the disclosure on iOS
    if (window.Capacitor?.getPlatform() === 'ios') {
      const userConfirmed = await showExternalPaymentDisclosure();
      if (!userConfirmed) return;
    }
    
    await openPaymentLink();
  } catch (error) {
    console.error('Payment error:', error);
    await Dialog.alert({
      title: 'Payment Error',
      message: 'There was an error initiating the payment. Please try again.'
    });
  } finally {
    isLoading.value = false;
  }
}
</script>

Gestión de diferentes regiones

Como las nuevas directrices de Apple solo se aplican a apps en la App Store de EE. UU., necesitarás una estrategia para detectar la región del usuario y aplicar el método de pago adecuado. Aquí tienes un enfoque más fiable usando geolocalización por IP:

import { Capacitor } from '@capacitor/core';

async function determinePaymentMethod() {
  // Always use Stripe for Android
  if (Capacitor.getPlatform() !== 'ios') {
    return 'external';
  }
  
  try {
    // Use a geolocation service to determine user's country
    const response = await fetch('https://ipapi.co/json/');
    const locationData = await response.json();
    
    // Check if the user is in the United States
    if (locationData.country_code === 'US') {
      return 'external'; // Can use Stripe Payment Links
    } else {
      return 'iap'; // Must use In-App Purchases
    }
  } catch (error) {
    console.error('Error detecting region:', error);
    return 'iap'; // Default to IAP to be safe
  }
}

export async function processPayment(product, userEmail, userId) {
  const paymentMethod = await determinePaymentMethod();
  
  if (paymentMethod === 'external') {
    // Use Stripe Payment Links
    await initiateExternalPayment(userEmail, userId);
  } else {
    // Use Apple's In-App Purchase
    await initiateInAppPurchase(product.appleProductId);
  }
}

Este enfoque utiliza el servicio gratuito ipapi.co servicio para determinar el país del usuario según su dirección IP. También puedes usar otros servicios de geolocalización como MaxMind o implementar esta validación en el servidor para mayor seguridad.

Nota: Aunque este enfoque funciona, recuerda que la geolocalización por IP no siempre es 100% precisa. Para aplicaciones críticas, considera usar múltiples métodos de detección o permitir que los usuarios seleccionen su región manualmente.

Detección de ubicación más precisa con plugins de Capacitor

Para una detección de ubicación más exacta, puedes usar el plugin Capacitor Geolocation junto con @capgo/capacitor-nativegeocoder para determinar el país del usuario con mayor precisión:

Primero, instala los plugins necesarios:

npm install @capacitor/geolocation @capgo/capacitor-nativegeocoder

Configura los plugins en tu proyecto Capacitor. Añade lo siguiente a tu capacitor.config.ts:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  // Your existing app configuration (appId, appName, etc.)
  plugins: {
    Geolocation: {
      // Request precise location access on iOS
      iosLocationAccuracy: 'reduced'
    }
  }
};

export default config;

Implementa la detección de región basada en la ubicación:

import { Capacitor } from '@capacitor/core';
import { Geolocation } from '@capacitor/geolocation';
import { NativeGeocoder } from '@capgo/capacitor-nativegeocoder';

async function isUserInUSA() {
  try {
    // Request permission first
    const permissionStatus = await Geolocation.requestPermissions();
    
    if (permissionStatus.location === 'granted') {
      // Get current position
      const position = await Geolocation.getCurrentPosition({
        timeout: 10000,
        enableHighAccuracy: false
      });
      
      // Use NativeGeocoder to reverse geocode the coordinates
      const results = await NativeGeocoder.reverseGeocode({
        latitude: position.coords.latitude,
        longitude: position.coords.longitude,
        useLocale: true,
        maxResults: 1
      });
      
      if (results.addresses.length > 0) {
        // Check if the user is in the USA
        return results.addresses[0].countryCode === 'US';
      }
    }
    
    // If we couldn't determine location or permission denied, fall back to IP detection
    return await isUserInUSAByIP();
  } catch (error) {
    console.error('Error detecting location:', error);
    // Fall back to IP detection on error
    return await isUserInUSAByIP();
  }
}

async function isUserInUSAByIP() {
  try {
    const response = await fetch('https://ipapi.co/json/');
    const data = await response.json();
    return data.country_code === 'US';
  } catch (error) {
    console.error('Error detecting IP location:', error);
    return false; // Default to false to be safe
  }
}

export async function determinePaymentMethod() {
  // Always use Stripe for Android
  if (Capacitor.getPlatform() !== 'ios') {
    return 'external';
  }
  
  // Check if user is in the USA
  const isUSA = await isUserInUSA();
  return isUSA ? 'external' : 'iap';
}

export async function processPayment(product, userEmail, userId) {
  const paymentMethod = await determinePaymentMethod();
  
  if (paymentMethod === 'external') {
    // Use Stripe Payment Links
    await initiateExternalPayment(userEmail, userId);
  } else {
    // Use Apple's In-App Purchase
    await initiateInAppPurchase(product.appleProductId);
  }
}

Esta implementación ofrece una forma más precisa de determinar si un usuario se encuentra físicamente en Estados Unidos. Primero intenta usar el GPS del dispositivo y el geocoder nativo. Si falla (por permisos u otros errores), recurre a la detección por IP.

No olvides añadir los permisos necesarios a tus info.plist (iOS) y AndroidManifest.xml archivos (Android):

Para iOS (ios/App/App/Info.plist):

<key>NSLocationWhenInUseUsageDescription</key>
<string>We need your location to determine which payment method to use based on regional availability.</string>

Para Android (android/app/src/main/AndroidManifest.xml):

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Este enfoque es la forma más precisa de determinar si un usuario es apto para opciones de pago externas según las nuevas directrices de Apple.

Gestión de suscripciones

Una ventaja clave de usar Stripe para pagos es la capacidad de ofrecer y gestionar suscripciones. Así es como puedes manejar la gestión de suscripciones en tu app de Capacitor:

1. Crear una página de gestión de suscripciones

Añade una página de gestión de suscripciones en tu app para mostrar las suscripciones activas del usuario:

<template>
  <div class="subscription-manager">
    <div v-if="isLoading" class="loading-indicator">
      Loading subscription data...
    </div>
    
    <div v-else-if="subscription" class="subscription-info">
      <h2 class="mb-4 text-xl font-bold">Your Subscription</h2>
      
      <div class="mb-6 plan-details">
        <p><span class="font-medium">Plan:</span> {{ subscription.planName }}</p>
        <p><span class="font-medium">Status:</span> {{ subscription.status }}</p>
        <p><span class="font-medium">Renews:</span> {{ formatDate(subscription.currentPeriodEnd) }}</p>
      </div>
      
      <button 
        @click="manageSubscription" 
        class="py-3 w-full font-medium text-white bg-indigo-600 rounded-lg transition-colors hover:bg-indigo-700"
      >
        Manage Subscription
      </button>
    </div>
    
    <div v-else class="no-subscription">
      <p class="mb-4">You don't have an active subscription.</p>
      <button 
        @click="goToPricingPage" 
        class="py-3 w-full font-medium text-white bg-indigo-600 rounded-lg transition-colors hover:bg-indigo-700"
      >
        View Plans
      </button>
    </div>
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue';
import { getUserSubscription } from '../services/subscription';

const subscription = ref(null);
const isLoading = ref(true);

onMounted(async () => {
  try {
    const userData = await getUserSubscription();
    subscription.value = userData.subscription;
  } catch (error) {
    console.error('Failed to load subscription:', error);
  } finally {
    isLoading.value = false;
  }
});

function formatDate(timestamp) {
  return new Date(timestamp * 1000).toLocaleDateString();
}

function manageSubscription() {
  // Open Stripe Customer Portal
  window.open(subscription.value.portalUrl, '_blank');
}

function goToPricingPage() {
  // Navigate to pricing page
  // router.push('/pricing');
}
</script>

2. Customer Portal para la gestión de suscripciones

Stripe ofrece un Customer Portal que permite a los usuarios gestionar sus suscripciones. Puedes crear un enlace a este portal desde tu servidor:

// Server-side code (Node.js)
const stripe = require('stripe')('sk_your_stripe_secret_key');

async function createPortalSession(customerId) {
  const session = await stripe.billingPortal.sessions.create({
    customer: customerId,
    return_url: 'https://yourdomain.com/account',
  });
  
  return session.url;
}

Cumplimiento con la App Store

Para asegurar que tu implementación cumpla con las directrices de Apple:

Incluye las divulgaciones adecuadas sobre compras externas
Implementa un modal sheet para informar a los usuarios que saldrán de la app (según lo requiere Apple)
No intentes eludir la comisión de Apple en las compras realizadas dentro de la app
Comunica claramente a los usuarios que Apple no es responsable de la transacción

Aquí tienes un ejemplo de cómo implementar el modal de aviso requerido:

import { Dialog } from '@capacitor/dialog';

async function showExternalPaymentDisclosure() {
  const { value } = await Dialog.confirm({
    title: 'Leaving App for Payment',
    message: 'You are about to leave this app to make a payment. Apple is not responsible for the privacy or security of payments that are not made through the App Store. All payment-related issues, including refunds, must be handled by our support team.',
    okButtonTitle: 'Continue',
    cancelButtonTitle: 'Cancel'
  });
  
  return value;
}

export async function initiateExternalPayment(userEmail, userId) {
  const userConfirmed = await showExternalPaymentDisclosure();
  
  if (userConfirmed) {
    await openPaymentLink(userEmail, userId);
  }
}

Prueba tu implementación

Para probar tu implementación:

Haz clic en el botón de pago de tu app; debería mostrar el aviso y luego abrir la página de pago de Stripe
Realiza un pago de prueba con una tarjeta de Stripe de prueba 4242 4242 4242 4242
Tras el pago, deberías ser redirigido de vuelta a tu app mediante el universal link
Comprueba que tu webhook recibió el checkout.session.completed evento

Conclusión

La posibilidad de usar métodos de pago externos para productos digitales en apps iOS es un cambio significativo que da a los desarrolladores más flexibilidad. Aunque este cambio por ahora solo aplica a apps de la App Store de EE. UU., ofrece una alternativa importante al sistema de compras in-app de Apple.

Al usar Stripe Payment Links con Capacitor, puedes implementar rápidamente una experiencia de checkout simplificada y a la vez cumplir con las directrices de Apple. Para usuarios fuera de EE. UU., donde el sistema de compras in-app de Apple sigue aplicando, @capgo/native-purchases implementa StoreKit y Google Play Billing directamente. Este enfoque también te da la ventaja de la robusta infraestructura de pagos de Stripe, comisiones de procesamiento más bajas (3% vs 30%) y pagos mucho más rápidos (días en lugar de meses) frente al sistema de compras in-app de Apple.

Recuerda que deberás gestionar directamente todo el soporte al cliente y los reembolsos, ya que estas transacciones ocurren fuera del ecosistema de Apple.

¿Ya implementaste Stripe Payment Links en tu app con Capacitor? ¡Comparte tu experiencia en los comentarios!

FAQs

P: ¿Este enfoque cumple con las directrices de Apple?
R: Sí, desde el 1 de mayo de 2025, Apple permite enlazar a métodos de pago externos para productos y servicios digitales en apps distribuidas en la App Store de EE. UU., siempre que incluyas las divulgaciones requeridas.

P: ¿Debo pagar la comisión de Apple al usar métodos de pago externos?
R: No, uno de los mayores beneficios de las nuevas reglas es que los pagos procesados fuera del sistema de Apple no están sujetos a su comisión.

P: ¿Mi empresa debe estar basada en Estados Unidos para aprovechar estas nuevas reglas?
R: No, cualquier empresa de cualquier parte del mundo puede implementar métodos de pago externos siempre que tu app esté disponible en la App Store de EE. UU. y los usuarios que realicen las compras se encuentren en Estados Unidos. La normativa se aplica al marketplace (la App Store de EE. UU.) y a la ubicación de los usuarios, no a la ubicación de tu empresa. Esto significa que desarrolladores de Europa, Asia, Sudamérica o cualquier otro lugar pueden implementar Stripe Payment Links para sus clientes en EE. UU.

P: ¿Qué pasa si un usuario fuera de EE. UU. intenta usar la opción de pago externa?
R: Deberías implementar la detección de región (como se muestra en el artículo) para ofrecer opciones de pago externas solo a los usuarios en EE. UU. Para otras regiones, deberías seguir usando el sistema de compras dentro de la app de Apple.

P: ¿Puedo usar esto para bienes físicos o servicios consumidos fuera de la app?
R: Sí, Apple siempre ha permitido métodos de pago externos para bienes físicos y servicios consumidos fuera de la app (como transporte compartido o reparto de comida).

Sigue leyendo desde Stripe Payments en Capacitor: Nuevas directrices de Apple

Si estás usando Pagos con Stripe en Capacitor: nuevas directrices de Apple para planificar la seguridad y el cumplimiento, conéctalo con Cifrado para los detalles de implementación en Cifrado, Cumplimiento para los detalles de implementación en Cumplimiento, Escáner de seguridad de Capgo para el flujo de trabajo del producto en Capgo Security Scanner, Seguridad de Capgo para el flujo de trabajo del producto en Capgo Security, y Centro de confianza de Capgo para el flujo de trabajo del producto en Capgo Trust Center.