Saltar al contenido principal

Instalación

1

Instala el paquete

Ejecuta el siguiente comando en la raíz de tu proyecto:
npm install @dodopayments/express
2

Configura las variables de entorno

Crea un archivo .env en la raíz de tu proyecto:
DODO_PAYMENTS_API_KEY=your-api-key
DODO_PAYMENTS_WEBHOOK_KEY=your-webhook-secret
DODO_PAYMENTS_ENVIRONMENT="test_mode" or "live_mode"
DODO_PAYMENTS_RETURN_URL=your-return-url
Nunca cometas tu archivo .env o secretos en el control de versiones.

Ejemplos de Manejadores de Rutas

Usa este manejador para integrar el proceso de pago de Dodo Payments en tu aplicación Express. Soporta flujos de pago estáticos (GET), dinámicos (POST) y de sesión (POST).
import { checkoutHandler } from '@dodopayments/express';

app.get('/api/checkout', checkoutHandler({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "static"
}))

app.post('/api/checkout', checkoutHandler({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "dynamic"
}))

app.post('/api/checkout', checkoutHandler({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
    returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
    environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
    type: "session"
}))
curl --request GET \
--url 'https://example.com/api/checkout?productId=pdt_fqJhl7pxKWiLhwQR042rh' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test
curl --request POST \
--url https://example.com/api/checkout \
--header 'Content-Type: application/json' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test \
--data '{
"billing": {
  "city": "Texas",
  "country": "US",
  "state": "Texas",
  "street": "56, hhh",
  "zipcode": "560000"
},
"customer": {
  "email": "[email protected]",
  	"name": "test"
},
"metadata": {},
"payment_link": true,
  "product_id": "pdt_QMDuvLkbVzCRWRQjLNcs",
  "quantity": 1,
  "billing_currency": "USD",
  "discount_code": "IKHZ23M9GQ",
  "return_url": "https://example.com",
  "trial_period_days": 10
}'
curl --request POST \
--url https://example.com/api/checkout \
--header 'Content-Type: application/json' \
--header 'User-Agent: insomnia/11.2.0' \
--cookie mode=test \
--data '{
"product_cart": [
  {
    "product_id": "pdt_QMDuvLkbVzCRWRQjLNcs",
    "quantity": 1
  }
],
"customer": {
  "email": "[email protected]",
  "name": "test"
},
"return_url": "https://example.com/success"
}'

Manejador de Ruta de Checkout

Dodo Payments soporta tres tipos de flujos de pago para integrar pagos en tu sitio web, este adaptador soporta todos los tipos de flujos de pago.
  • Enlaces de Pago Estáticos: URLs instantáneamente compartibles para la recolección de pagos rápida y sin código.
  • Enlaces de Pago Dinámicos: Genera programáticamente enlaces de pago con detalles personalizados utilizando la API o SDKs.
  • Sesiones de Checkout: Crea experiencias de checkout seguras y personalizables con carritos de productos preconfigurados y detalles del cliente.

Parámetros de Consulta Soportados

productId
string
required
Identificador del producto (por ejemplo, ?productId=pdt_nZuwz45WAs64n3l07zpQR).
quantity
integer
Cantidad del producto.
fullName
string
Nombre completo del cliente.
firstName
string
Nombre del cliente.
lastName
string
Apellido del cliente.
email
string
Dirección de correo electrónico del cliente.
country
string
País del cliente.
addressLine
string
Línea de dirección del cliente.
city
string
Ciudad del cliente.
state
string
Estado/provincia del cliente.
zipCode
string
Código postal del cliente.
disableFullName
boolean
Deshabilitar el campo de nombre completo.
disableFirstName
boolean
Deshabilitar el campo de nombre.
disableLastName
boolean
Deshabilitar el campo de apellido.
disableEmail
boolean
Deshabilitar el campo de correo electrónico.
disableCountry
boolean
Deshabilitar el campo de país.
disableAddressLine
boolean
Deshabilitar el campo de línea de dirección.
disableCity
boolean
Deshabilitar el campo de ciudad.
disableState
boolean
Deshabilitar el campo de estado.
disableZipCode
boolean
Deshabilitar el campo de código postal.
paymentCurrency
string
Especifica la moneda de pago (por ejemplo, USD).
showCurrencySelector
boolean
Mostrar selector de moneda.
paymentAmount
integer
Especifica el monto del pago (por ejemplo, 1000 para $10.00).
showDiscounts
boolean
Mostrar campos de descuento.
metadata_*
string
Cualquier parámetro de consulta que comience con metadata_ se pasará como metadatos.
Si falta productId, el manejador devuelve una respuesta 400. Los parámetros de consulta inválidos también resultan en una respuesta 400.

Formato de Respuesta

El checkout estático devuelve una respuesta JSON con la URL de checkout:
{
  "checkout_url": "https://checkout.dodopayments.com/..."
}

Formato de Respuesta

El checkout dinámico devuelve una respuesta JSON con la URL de checkout:
{
  "checkout_url": "https://checkout.dodopayments.com/..."
}
Las sesiones de checkout proporcionan una experiencia de checkout más segura y alojada que maneja el flujo de pago completo tanto para compras únicas como para suscripciones con control total de personalización.Consulta la Guía de Integración de Sesiones de Checkout para más detalles y una lista completa de los campos soportados.

Formato de Respuesta

Las sesiones de checkout devuelven una respuesta JSON con la URL de checkout:
{
  "checkout_url": "https://checkout.dodopayments.com/session/..."
}

Manejador de Ruta del Portal del Cliente

El Manejador de Ruta del Portal del Cliente te permite integrar sin problemas el portal del cliente de Dodo Payments en tu aplicación Express.

Parámetros de Consulta

customer_id
string
required
El ID del cliente para la sesión del portal (por ejemplo, ?customer_id=cus_123).
send_email
boolean
Si se establece en true, se envía un correo electrónico al cliente con el enlace del portal.
Devuelve 400 si falta customer_id.

Manejador de Ruta de Webhook

  • Método: Solo se admiten solicitudes POST. Otros métodos devuelven 405.
  • Verificación de Firma: Verifica la firma del webhook utilizando webhookKey. Devuelve 401 si la verificación falla.
  • Validación de Carga Útil: Validada con Zod. Devuelve 400 para cargas útiles inválidas.
  • Manejo de Errores:
    • 401: Firma inválida
    • 400: Carga útil inválida
    • 500: Error interno durante la verificación
  • Enrutamiento de Eventos: Llama al manejador de eventos apropiado según el tipo de carga útil.

Manejadores de Eventos de Webhook Soportados

onPayload?: (payload: WebhookPayload) => Promise<void>;
onPaymentSucceeded?: (payload: WebhookPayload) => Promise<void>;
onPaymentFailed?: (payload: WebhookPayload) => Promise<void>;
onPaymentProcessing?: (payload: WebhookPayload) => Promise<void>;
onPaymentCancelled?: (payload: WebhookPayload) => Promise<void>;
onRefundSucceeded?: (payload: WebhookPayload) => Promise<void>;
onRefundFailed?: (payload: WebhookPayload) => Promise<void>;
onDisputeOpened?: (payload: WebhookPayload) => Promise<void>;
onDisputeExpired?: (payload: WebhookPayload) => Promise<void>;
onDisputeAccepted?: (payload: WebhookPayload) => Promise<void>;
onDisputeCancelled?: (payload: WebhookPayload) => Promise<void>;
onDisputeChallenged?: (payload: WebhookPayload) => Promise<void>;
onDisputeWon?: (payload: WebhookPayload) => Promise<void>;
onDisputeLost?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionActive?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionOnHold?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionRenewed?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionPlanChanged?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionCancelled?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionFailed?: (payload: WebhookPayload) => Promise<void>;
onSubscriptionExpired?: (payload: WebhookPayload) => Promise<void>;
onLicenseKeyCreated?: (payload: WebhookPayload) => Promise<void>;

Solicitud para LLM

Eres un asistente experto en desarrollo de Express.js. Tu tarea es guiar a un usuario a través de la integración del adaptador @dodopayments/express en su proyecto existente de Express.js.

El adaptador @dodopayments/express proporciona manejadores de ruta para las funcionalidades de Checkout, Portal del Cliente y Webhook de Dodo Payments, diseñados para integrarse directamente en una aplicación Express.

Primero, instala el paquete necesario. Usa el gestor de paquetes apropiado para el proyecto del usuario (npm, yarn o bun):

npm install @dodopayments/express

---

Aquí te mostramos cómo deberías estructurar tu respuesta:

1. Pregunta al usuario qué funcionalidades desea integrar.

"¿Qué partes del adaptador @dodopayments/express te gustaría integrar en tu proyecto? Puedes elegir una o más de las siguientes:

- Manejador de Ruta de Checkout (para manejar checkouts de productos)
- Manejador de Ruta del Portal del Cliente (para gestionar suscripciones/detalles del cliente)
- Manejador de Ruta de Webhook (para recibir eventos de webhook de Dodo Payments)
- Todo (integrar los tres)"

---

2. Según la selección del usuario, proporciona pasos de integración detallados para cada funcionalidad elegida.

---

**Si se selecciona el Manejador de Ruta de Checkout:**

**Propósito**: Este manejador gestiona diferentes tipos de flujos de checkout. Todos los tipos de checkout (estáticos, dinámicos y sesiones) devuelven respuestas JSON con URLs de checkout para manejo programático.

**Integración**:
Crea rutas en tu aplicación Express para checkout estático (GET), dinámico (POST) y sesiones de checkout (POST).

import { checkoutHandler } from '@dodopayments/express';

app.get('/api/checkout', checkoutHandler({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
  type: "static"
}));

app.post('/api/checkout', checkoutHandler({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
  type: "dynamic"
}));

// Para sesiones de checkout
app.post('/api/checkout', checkoutHandler({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  returnUrl: process.env.DODO_PAYMENTS_RETURN_URL,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
  type: "session"
}));

Opciones de Configuración:

    bearerToken: Tu clave API de Dodo Payments (se recomienda almacenarla en la variable de entorno DODO_PAYMENTS_API_KEY).

    returnUrl (opcional): URL para redirigir al usuario después de un checkout exitoso.

    environment: "test_mode" o "live_mode"

    type: "static" (GET), "dynamic" (POST), o "session" (POST)

GET (checkout estático) espera parámetros de consulta:

    productId (requerido)

    quantity, campos del cliente (fullName, email, etc.), y metadatos (metadata_*) son opcionales.

    Devuelve: {"checkout_url": "https://checkout.dodopayments.com/..."}

POST (checkout dinámico) espera un cuerpo JSON con detalles de pago (único o suscripción). Consulta la documentación para el esquema completo del POST:

    Pagos únicos: https://docs.dodopayments.com/api-reference/payments/post-payments

    Suscripciones: https://docs.dodopayments.com/api-reference/subscriptions/post-subscriptions

    Devuelve: {"checkout_url": "https://checkout.dodopayments.com/..."}

POST (sesiones de checkout) - (Recomendado) Una experiencia de checkout más personalizable. Devuelve JSON con checkout_url: Los parámetros se envían como un cuerpo JSON. Soporta tanto pagos únicos como recurrentes. Devuelve: {"checkout_url": "https://checkout.dodopayments.com/session/..."}. Para una lista completa de los campos soportados, consulta:

  Guía de Integración de Sesiones de Checkout: https://docs.dodopayments.com/developer-resources/checkout-session

Si se selecciona el Manejador de Ruta del Portal del Cliente:

Propósito: Esta ruta permite a los clientes gestionar sus suscripciones a través del portal de Dodo Payments.

Integración:

import { CustomerPortal } from "@dodopayments/express";

app.get('/api/customer-portal', CustomerPortal({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  environment: process.env.DODO_PAYMENTS_ENVIRONMENT,
}));

Parámetros de Consulta:

    customer_id (requerido): por ejemplo, ?customer_id=cus_123

    send_email (opcional): si es verdadero, se envía al cliente el enlace del portal

Devuelve 400 si falta customer_id.

Si se selecciona el Manejador de Ruta de Webhook:

Propósito: Procesa eventos de webhook entrantes de Dodo Payments para activar eventos en tu aplicación.

Integración:

import { Webhooks } from "@dodopayments/express";

app.post('/api/webhook', Webhooks({
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
  onPayload: async (payload) => {
    // Manejar carga útil genérica
  },
  // También puedes proporcionar manejadores específicos para cada tipo de evento a continuación
}));

Características:

    Solo se permite el método POST — otros devuelven 405

    La verificación de firma se realiza utilizando webhookKey. Devuelve 401 si es inválido.

    Validación de carga útil basada en Zod. Devuelve 400 si el esquema es inválido.

    Todos los manejadores son funciones asíncronas.

Manejadores de Eventos de Webhook Soportados:

Puedes pasar cualquiera de los siguientes manejadores:

    onPayload

    onPaymentSucceeded

    onPaymentFailed

    onPaymentProcessing

    onPaymentCancelled

    onRefundSucceeded

    onRefundFailed

    onDisputeOpened, onDisputeExpired, onDisputeAccepted, onDisputeCancelled, onDisputeChallenged, onDisputeWon, onDisputeLost

    onSubscriptionActive, onSubscriptionOnHold, onSubscriptionRenewed, onSubscriptionPlanChanged, onSubscriptionCancelled, onSubscriptionFailed, onSubscriptionExpired

    onLicenseKeyCreated

Configuración de Variables de Entorno:

Asegúrate de definir estas variables de entorno en tu proyecto:

DODO_PAYMENTS_API_KEY=tu-clave-api
DODO_PAYMENTS_WEBHOOK_KEY=tu-secreto-webhook
DODO_PAYMENTS_ENVIRONMENT="test_mode" o "live_mode"
DODO_PAYMENTS_RETURN_URL=tu-url-de-retorno

Úsalas dentro de tu código como:

process.env.DODO_PAYMENTS_API_KEY
process.env.DODO_PAYMENTS_WEBHOOK_SECRET

Nota de Seguridad: NO cometas secretos en el control de versiones. Usa archivos .env localmente y gestores de secretos en entornos de despliegue (por ejemplo, AWS, Vercel, Heroku, etc.).