---
title: "Habilitar compras usando paywalls en Unity SDK"
description: "Aprende cómo presentar paywalls en tu aplicación Unity con el SDK de Adapty."
---

Para habilitar las compras in-app, necesitas entender tres conceptos clave:

- [**Productos**](product) – cualquier cosa que los usuarios pueden comprar (suscripciones, consumibles, acceso de por vida)
- Los [**paywalls**](paywalls) son configuraciones que definen qué productos ofrecer. En Adapty, los paywalls son la única forma de recuperar productos, pero este diseño te permite modificar ofertas, precios y combinaciones de productos sin tocar el código de tu app.
- Los [**placements**](placements) – dónde y cuándo muestras los paywalls en tu app (como `main`, `onboarding`, `settings`). Configuras los paywalls para los placements en el dashboard y luego los solicitas por ID de placement en tu código. Esto facilita la ejecución de pruebas A/B y mostrar diferentes paywalls a distintos usuarios.

Adapty te ofrece tres formas de habilitar compras en tu app. Selecciona una según los requisitos de tu aplicación:

| Implementación            | Complejidad | Cuándo usarla                                                                                                                                                                                                                              |
|---------------------------|-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Adapty Paywall Builder    | ✅ Fácil     | [Creas un paywall completo y listo para compras en el editor sin código](quickstart-paywalls). Adapty lo renderiza automáticamente y gestiona todo el flujo de compra, la validación de recibos y la gestión de suscripciones entre bastidores. |
| Paywalls creados manualmente | 🟡 Medio  | Implementas la UI de tu paywall en el código de tu app, pero igualmente obtienes el objeto paywall de Adapty para mantener flexibilidad en las ofertas de productos. Consulta la [guía](unity-quickstart-manual).                           |
| Modo observador           | 🔴 Difícil  | Ya tienes tu propia infraestructura de gestión de compras y quieres seguir usándola. Ten en cuenta que el modo observador tiene sus limitaciones en Adapty. Consulta el [artículo](observer-vs-full-mode).                                  |

:::important
**Los pasos a continuación muestran cómo implementar un paywall creado en el Adapty Paywall Builder.**

Si no quieres usar el Paywall Builder, consulta la [guía para gestionar compras en paywalls creados manualmente](unity-making-purchases).
:::

Para mostrar un paywall creado en el Adapty Paywall Builder, en el código de tu app solo necesitas:

1. **Obtener el paywall**: Obtener el paywall de Adapty.
2. **Mostrar el paywall y Adapty gestionará las compras por ti**: Muestra el contenedor del paywall que obtuviste en tu app.
3. **Gestionar las acciones de los botones**: Asocia las interacciones del usuario con el paywall con la respuesta de tu app a ellas. Por ejemplo, abrir enlaces o cerrar el paywall cuando los usuarios pulsan botones.

## Antes de empezar \{#before-you-start\}

Antes de empezar, completa estos pasos:

1. Conecta tu app al [App Store](initial_ios) y/o [Google Play](initial-android) en el Adapty Dashboard.
2. [Crea tus productos](create-product) en Adapty.
3. [Crea un paywall y añade productos](create-paywall).
4. [Crea un placement y añade tu paywall](create-placement).
5. [Instala y activa el SDK de Adapty](sdk-installation-unity) en el código de tu app.

:::tip
La forma más rápida de completar estos pasos es seguir la [guía de inicio rápido](quickstart) o crear paywalls y placements usando el [CLI para desarrolladores](developer-cli-quickstart).
:::

## 1. Obtener el paywall \{#1-get-the-paywall\}

Tus paywalls están asociados a placements configurados en el dashboard. Los placements te permiten ejecutar distintos paywalls para diferentes audiencias o realizar [pruebas A/B](ab-tests).

Para obtener un paywall creado en el Adapty Paywall Builder, necesitas:

1. Obtener el objeto `paywall` por el ID del [placement](placements) usando el método `GetPaywall` y comprobar si fue creado en el builder mediante la propiedad `HasViewConfiguration`.

2. Crear la vista del paywall usando el método `CreatePaywallView`. La vista contiene los elementos de UI y el estilo necesarios para mostrar el paywall.

:::important
Para obtener la configuración de la vista, debes activar el toggle **Show on device** en el Paywall Builder. De lo contrario, obtendrás una configuración de vista vacía y el paywall no se mostrará.
:::

```csharp showLineNumbers
Adapty.GetPaywall("YOUR_PLACEMENT_ID", (paywall, error) => {
    if(error != null) {
        // handle the error
        return;
    }
    
    // Create paywall view parameters
    var parameters = new AdaptyUICreatePaywallViewParameters();
    
    // Create the paywall view
    AdaptyUI.CreatePaywallView(paywall, parameters, (view, error) => {
        if(error != null) {
            // handle the error
            return;
        }
        
        // view - the paywall view ready to be presented
    });
});
```

:::info
Este inicio rápido proporciona la configuración mínima necesaria para mostrar un paywall. Para detalles de configuración avanzada, consulta nuestra [guía sobre cómo obtener paywalls](unity-get-pb-paywalls).
:::

## 2. Mostrar el paywall \{#2-display-the-paywall\}

Ahora que tienes la configuración del paywall, basta con añadir unas pocas líneas para mostrarlo.

Para mostrar el paywall, usa el método `view.Present()` en el `view` creado por el método `CreatePaywallView`. Cada `view` solo puede usarse una vez. Si necesitas mostrar el paywall de nuevo, llama a `CreatePaywallView` otra vez para crear una nueva instancia de `view`.

```csharp showLineNumbers title="Unity"
view.Present((error) => {
  // handle the error
});
```

:::info
Para más detalles sobre cómo mostrar un paywall, consulta nuestra [guía](unity-present-paywalls).
:::

## 3. Gestionar las acciones de los botones \{#3-handle-button-actions\}

Cuando los usuarios pulsan botones en el paywall, el SDK de Unity gestiona automáticamente las compras y la restauración. Sin embargo, otros botones tienen IDs personalizados o predefinidos y requieren gestionar las acciones en tu código.

Por ejemplo, tu paywall probablemente tenga un botón de cerrar y URLs que abrir (p. ej., términos de uso y política de privacidad). Para gestionar estas acciones, tu clase debe implementar la interfaz `AdaptyPaywallsEventsListener` y registrarse como listener.

:::tip
Lee nuestras guías sobre cómo gestionar [acciones](unity-handle-paywall-actions) y [eventos](unity-handling-events) de botones.
:::

```csharp showLineNumbers title="Unity"
public class YourClass : MonoBehaviour, AdaptyPaywallsEventsListener
{
    void Start()
    {
        // Register this class as the paywall events listener
        Adapty.SetPaywallsEventsListener(this);
    }

    // AdaptyPaywallsEventsListener method - handles button actions
    public void PaywallViewDidPerformAction(
        AdaptyUIPaywallView view,
        AdaptyUIUserAction action
    ) {
        switch (action.Type) {
            case AdaptyUIUserActionType.Close:
                view.Dismiss(null);
                break;
            case AdaptyUIUserActionType.OpenUrl:
                Application.OpenURL(action.Value);
                break;
            default:
                break;
        }
    }
}
```

## Próximos pasos \{#next-steps\}

---
no_index: true
---
import Callout from '../../../components/Callout.astro';

<Callout type="tip">
¿Tienes preguntas o estás teniendo algún problema? Consulta nuestro [foro de soporte](https://adapty.featurebase.app/) donde encontrarás respuestas a preguntas frecuentes o podrás plantear las tuyas. ¡Nuestro equipo y la comunidad están aquí para ayudarte!
</Callout>

Tu paywall está listo para mostrarse en la app. Prueba tus compras en el [sandbox del App Store](test-purchases-in-sandbox) o en [Google Play Store](testing-on-android) para asegurarte de que puedes completar una compra de prueba desde el paywall.

Ahora necesitas [comprobar el nivel de acceso de los usuarios](unity-check-subscription-status) para asegurarte de que muestras un paywall o das acceso a las funciones de pago a los usuarios correctos.

## Ejemplo completo \{#full-example\}

Así es como todos esos pasos pueden integrarse juntos en tu app.

```csharp showLineNumbers
using System;
using UnityEngine;
using AdaptySDK;

public class PaywallManager : MonoBehaviour, AdaptyPaywallsEventsListener
{
    [SerializeField] private string placementId = "YOUR_PLACEMENT_ID";
    
    private AdaptyUIPaywallView currentPaywallView;
    
    void Start()
    {
        // Register for paywall events
        Adapty.SetPaywallsEventsListener(this);
        GetAndDisplayPaywall();
    }
    
    private void GetAndDisplayPaywall()
    {
        Adapty.GetPaywall(placementId, (paywall, error) => {
            if (error != null) {
                Debug.LogError("Error getting paywall: " + error.Message);
                return;
            }
            
            if (paywall.HasViewConfiguration) {
                CreateAndPresentPaywallView(paywall);
            } else {
                Debug.LogWarning("Paywall was not created using the builder");
            }
        });
    }
    
    private void CreateAndPresentPaywallView(AdaptyPaywall paywall)
    {
        var parameters = new AdaptyUICreatePaywallViewParameters();
        
        AdaptyUI.CreatePaywallView(paywall, parameters, (view, error) => {
            if (error != null) {
                Debug.LogError("Error creating paywall view: " + error.Message);
                return;
            }
            
            currentPaywallView = view;
            
            view.Present((presentError) => {
                if (presentError != null) {
                    Debug.LogError("Error presenting paywall: " + presentError.Message);
                    return;
                }
                
                Debug.Log("Paywall presented successfully");
            });
        });
    }
    
    // AdaptyPaywallsEventsListener implementation
    public void PaywallViewDidPerformAction(
        AdaptyUIPaywallView view, 
        AdaptyUIUserAction action
    ) {
        switch (action.Type) {
            case AdaptyUIUserActionType.Close:
                Debug.Log("Close button pressed");
                view.Dismiss(null);
                break;
            case AdaptyUIUserActionType.OpenUrl:
                Application.OpenURL(action.Value);
                break;
            default:
                break;
        }
    }
    
    // Required interface methods (implement as needed)
    public void PaywallViewDidAppear(AdaptyUIPaywallView view) { }
    public void PaywallViewDidDisappear(AdaptyUIPaywallView view) { }
    public void PaywallViewDidSelectProduct(AdaptyUIPaywallView view, string productId) { }
    public void PaywallViewDidStartPurchase(AdaptyUIPaywallView view, AdaptyPaywallProduct product) { }
    public void PaywallViewDidFinishPurchase(AdaptyUIPaywallView view, AdaptyPaywallProduct product, AdaptyPurchaseResult purchasedResult) { }
    public void PaywallViewDidFailPurchase(AdaptyUIPaywallView view, AdaptyPaywallProduct product, AdaptyError error) { }
    public void PaywallViewDidStartRestore(AdaptyUIPaywallView view) { }
    public void PaywallViewDidFinishRestore(AdaptyUIPaywallView view, AdaptyProfile profile) { }
    public void PaywallViewDidFailRestore(AdaptyUIPaywallView view, AdaptyError error) { }
    public void PaywallViewDidFailRendering(AdaptyUIPaywallView view, AdaptyError error) { }
    public void PaywallViewDidFailLoadingProducts(AdaptyUIPaywallView view, AdaptyError error) { }
    public void PaywallViewDidFinishWebPaymentNavigation(AdaptyUIPaywallView view, AdaptyPaywallProduct product, AdaptyError error) { }
    
    public void ShowPaywall()
    {
        GetAndDisplayPaywall();
    }
    
    void OnDestroy()
    {
        if (currentPaywallView != null) {
            currentPaywallView.Dismiss(null);
        }
    }
}
```