Pago Dinámico en el Checkout con Paga lo que Quieras

Pay What You Want (PWYW) te permite ofrecer precios variables para un solo producto sin crear varias entradas de producto. Estableces un precio mínimo en el dashboard y, después, envías importes dinámicos al crear sesiones de checkout o permites que los clientes elijan su precio. Este enfoque funciona para:

Precios variables sin gestionar varios productos
Precios definidos por el cliente, donde los compradores eligen el importe
Control de precios mediante programación, donde estableces el importe a través de la API
Modelos de precios flexibles para productos digitales, donaciones o lanzamientos experimentales

Pay What You Want solo está disponible para productos de pago único. No se puede utilizar con suscripciones. La moneda base del producto debe ser USD, GBP o EUR.

Requisitos previos

Un producto de pago único con Pay What You Want habilitado en el dashboard
El ID del producto (por ejemplo, pdt_123abc456def)
Una clave de API de Developer → API Keys

Habilitar Pay What You Want en un producto

En el dashboard de Dodo Payments:

Go to Products

Ve a Products y selecciona el producto de pago único que quieres configurar.

Enable Pay What You Want

En la sección Pricing, activa Pay What You Want.

Set the minimum price

Introduce el Minimum Price que los clientes deben pagar. Este campo es obligatorio.

Set a suggested price (optional)

Opcionalmente, establece un Suggested Price para orientar a los clientes. No existe una configuración de precio máximo. Para limitar el importe que cobras, aplica el límite en tu propio código antes de crear la sesión.

Save

Haz clic en Update Product y anota el ID de tu producto para utilizarlo en las sesiones de checkout.

Puedes encontrar el ID de tu producto en el dashboard, en Products → View Details, o mediante la API List Products.

Crear una sesión de checkout con un importe fijo

Cuando envías un amount en el carrito del producto, el checkout utiliza ese importe exacto como precio unitario, siempre que sea igual o superior al precio mínimo del producto. El campo amount utiliza la unidad monetaria más pequeña: centavos para USD, peniques para GBP y centavos para EUR. Por ejemplo, 1500 = $15.00 o €15.00.

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

const session = await client.checkoutSessions.create({
  product_cart: [
    {
      product_id: 'pdt_123abc456def',
      quantity: 1,
      amount: 1500, // $15.00 in cents
    }
  ],
  return_url: 'https://yoursite.com/success',
  metadata: {
    pricing_tier: 'custom'
  }
});

console.log('Checkout URL:', session.checkout_url);

import os
from dodopayments import DodoPayments

client = DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
)

session = client.checkout_sessions.create(
    product_cart=[
        {
            "product_id": "pdt_123abc456def",
            "quantity": 1,
            "amount": 1500,  # $15.00 in cents
        }
    ],
    return_url="https://yoursite.com/success",
    metadata={
        "pricing_tier": "custom"
    }
)

print(f"Checkout URL: {session.checkout_url}")

curl -X POST https://test.dodopayments.com/checkouts \
  -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "product_cart": [
      {
        "product_id": "pdt_123abc456def",
        "quantity": 1,
        "amount": 1500
      }
    ],
    "return_url": "https://yoursite.com/success"
  }'

El campo amount se ignora para los productos que no tienen Pay What You Want habilitado. Solo se aplica a pagos únicos.

Permitir que los clientes elijan su precio

Omite el campo amount para mostrar un campo de importe en el checkout. Los clientes pueden introducir cualquier importe igual o superior al precio mínimo de tu producto.

const session = await client.checkoutSessions.create({
  product_cart: [
    {
      product_id: 'pdt_123abc456def',
      quantity: 1,
      // No amount field — customer chooses
    }
  ],
  return_url: 'https://yoursite.com/success',
});

session = client.checkout_sessions.create(
    product_cart=[
        {
            "product_id": "pdt_123abc456def",
            "quantity": 1,
            # No amount field — customer chooses
        }
    ],
    return_url="https://yoursite.com/success",
)

curl -X POST https://test.dodopayments.com/checkouts \
  -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "product_cart": [
      {
        "product_id": "pdt_123abc456def",
        "quantity": 1
      }
    ],
    "return_url": "https://yoursite.com/success"
  }'

Utilizar Payment Links con importes dinámicos

Los enlaces de pago estáticos para productos Pay What You Want aceptan un parámetro de consulta paymentAmount que fija el importe cobrado. A diferencia de la API Checkout Sessions, este parámetro utiliza unidades monetarias principales (por ejemplo, 12.5 para $12.50).

https://checkout.dodopayments.com/buy/pdt_123abc456def?paymentAmount=15.00

paymentAmount utiliza unidades monetarias principales (15.00 equivale a $15.00). El campo de la API Checkout Sessions, product_cart[].amount, utiliza la unidad monetaria más pequeña (1500 equivale a $15.00). Consulta la guía de integración para obtener más información.

Patrones habituales

Precios escalonados por segmento de clientes

Cobra importes diferentes a distintos tipos de clientes utilizando el mismo producto:

async function createCheckoutForSegment(segment: string) {
  const amounts: Record<string, number> = {
    student: 1000,    // $10.00
    regular: 2500,    // $25.00
    premium: 5000,    // $50.00
  };

  return client.checkoutSessions.create({
    product_cart: [
      {
        product_id: 'pdt_123abc456def',
        quantity: 1,
        amount: amounts[segment],
      }
    ],
    return_url: 'https://yoursite.com/success',
    metadata: { segment },
  });
}

Precios basados en la cantidad

Ajusta el precio unitario según la cantidad comprada. amount es un precio por unidad y el total es amount × quantity:

async function createCheckoutWithQuantity(quantity: number) {
  const basePrice = 2000; // $20.00 per unit
  let discount = 0;

  if (quantity >= 5) {
    discount = 0.20; // 20% off
  } else if (quantity >= 2) {
    discount = 0.10; // 10% off
  }

  const unitAmount = Math.round(basePrice * (1 - discount));

  return client.checkoutSessions.create({
    product_cart: [
      {
        product_id: 'pdt_123abc456def',
        quantity,
        amount: unitAmount, // Charged per unit
      }
    ],
    return_url: 'https://yoursite.com/success',
  });
}

Precios promocionales

Aplica precios por tiempo limitado:

async function createCheckoutWithPromo() {
  const isPromoActive = checkIfPromotionActive(); // Your logic
  const regularPrice = 3000; // $30.00
  const promoPrice = 2000;   // $20.00

  return client.checkoutSessions.create({
    product_cart: [
      {
        product_id: 'pdt_123abc456def',
        quantity: 1,
        amount: isPromoActive ? promoPrice : regularPrice,
      }
    ],
    return_url: 'https://yoursite.com/success',
    metadata: {
      pricing_type: isPromoActive ? 'promotional' : 'regular',
    },
  });
}

Utiliza metadatos para registrar por qué se eligieron determinados importes (por ejemplo, pricing_tier, discount_code, user_segment). Esto te ayuda a analizar los patrones de precios y el comportamiento de los clientes.

Validar importes

Comprueba que el importe sea igual o superior al precio mínimo de tu producto antes de crear una sesión de checkout. maxAmount es tu propio límite comercial; Dodo Payments no tiene una configuración de precio máximo.

async function createValidatedCheckout(
  productId: string,
  amountInCents: number,
  minAmount: number,
  maxAmount: number | null
) {
  if (amountInCents < minAmount) {
    throw new Error(
      `Amount ${amountInCents} is below minimum ${minAmount}`
    );
  }

  if (maxAmount !== null && amountInCents > maxAmount) {
    throw new Error(
      `Amount ${amountInCents} exceeds maximum ${maxAmount}`
    );
  }

  return client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amountInCents,
      }
    ],
    return_url: 'https://yoursite.com/success',
  });
}

def create_validated_checkout(
    product_id: str,
    amount_in_cents: int,
    min_amount: int,
    max_amount: int | None
):
    if amount_in_cents < min_amount:
        raise ValueError(
            f"Amount {amount_in_cents} is below minimum {min_amount}"
        )

    if max_amount is not None and amount_in_cents > max_amount:
        raise ValueError(
            f"Amount {amount_in_cents} exceeds maximum {max_amount}"
        )

    return client.checkout_sessions.create(
        product_cart=[
            {
                "product_id": product_id,
                "quantity": 1,
                "amount": amount_in_cents,
            }
        ],
        return_url="https://yoursite.com/success",
    )

Solución de problemas

Amount is being ignored

Verifica que:

El producto tenga Pay What You Want habilitado en el dashboard
El producto sea de pago único y no una suscripción
El importe tenga el formato correcto (unidad monetaria más pequeña: centavos para USD, peniques para GBP y centavos para EUR)

Amount is below the minimum price

La API rechaza las sesiones de checkout cuyo importe sea inferior al precio mínimo de tu producto. Valida los importes antes de crear las sesiones u omite el campo amount para permitir que los clientes elijan.

Customer can't enter their own price

Si no aparece el campo de importe, asegúrate de haber omitido el campo amount del carrito del producto. Cuando se proporciona amount, el checkout utiliza ese importe exacto.

Checkout Sessions API

Referencia completa de la API para las sesiones de checkout.

Checkout Sessions Guide

Explora las funciones avanzadas de las sesiones de checkout y las opciones de personalización.

Pay What You Want Feature

Obtén más información sobre el modelo de precios Pay What You Want.

Integration Guides

Billing Deconstructions

Cookbooks

Pago Dinámico en el Checkout con Paga lo que Quieras

Requisitos previos

Habilitar Pay What You Want en un producto

Crear una sesión de checkout con un importe fijo

Permitir que los clientes elijan su precio

Utilizar Payment Links con importes dinámicos

Patrones habituales

Precios escalonados por segmento de clientes

Precios basados en la cantidad

Precios promocionales

Validar importes

Solución de problemas

Checkout Sessions API

Checkout Sessions Guide

Pay What You Want Feature

​Requisitos previos

​Habilitar Pay What You Want en un producto

​Crear una sesión de checkout con un importe fijo

​Permitir que los clientes elijan su precio

​Utilizar Payment Links con importes dinámicos

​Patrones habituales

​Precios escalonados por segmento de clientes

​Precios basados en la cantidad

​Precios promocionales

​Validar importes

​Solución de problemas

Checkout Sessions API

Checkout Sessions Guide

Pay What You Want Feature

Requisitos previos

Habilitar Pay What You Want en un producto

Crear una sesión de checkout con un importe fijo

Permitir que los clientes elijan su precio

Utilizar Payment Links con importes dinámicos

Patrones habituales

Precios escalonados por segmento de clientes

Precios basados en la cantidad

Precios promocionales

Validar importes

Solución de problemas