> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.recurrente.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.recurrente.com/_mcp/server.

# Crear un checkout

POST https://app.recurrente.com/api/checkouts
Content-Type: application/json

Crea una nueva sesión de checkout. Cada elemento del arreglo `items` puede declararse de dos maneras:

* **Con un producto existente** (recomendado): incluye `product_id` (o `price_id` si el producto tiene varios precios) y opcionalmente `quantity`. No envíes `name`, `amount_in_cents`, etc.; el producto ya tiene esa configuración.
* **Con detalles inline**: incluye `name`, `amount_in_cents`, `currency` y los demás campos del cobro. Recurrente creará un producto invisible bajo la cuenta y lo asociará al checkout.

Cuando usas `items`, no envíes `amount_in_cents` en la raíz del payload. El total del checkout se calcula sumando los ítems y debe alcanzar el mínimo de cobro: 500 para GTQ (Q5) o 100 para USD (\$1). Un ítem individual, como envío, puede ser menor al mínimo si el total del checkout sí lo cumple.

Ejemplo mínimo con un producto ya creado:

```json
{
  "items": [
    { "product_id": "prod_1234567", "quantity": 1 }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

### Cuotas en Checkout

En un checkout hospedado, tu integración controla qué opciones de cuotas se muestran con `available_installments`; el comprador escoge entre esas opciones al pagar. No envíes `installments` al crear un checkout para seleccionar la cantidad final de cuotas.

Para que un checkout muestre cuotas necesitas:

* Moneda `GTQ` (las cuotas no aplican en USD).
* Un cobro único (`charge_type: "one_time"`).
* Pagos con tarjeta habilitados en la cuenta, y una cuenta empresarial (las cuentas personales no pueden ofrecer cuotas).
* **No** hace falta que la cuenta esté verificada, ni habilitar nada con el adquirente.

Mientras la cuenta no complete su verificación sí aplica su tope de procesamiento sin verificación (Q500 en GTQ, \$50 en USD, acumulado). Si el total del checkout pasa ese tope, `POST /checkouts` responde `422` con `code: amount_exceeds_unverified_limit` y no crea el checkout, porque el comprador se habría topado con el bloqueo de cuenta no verificada en la página de pago. Completa la verificación de la cuenta para quitar el tope.

Si quieres que el checkout solo permita una cantidad específica de cuotas, muestra únicamente esa opción y desactiva el pago con tarjeta de contado:

```json
{
  "items": [
    {
      "name": "Pago en 6 cuotas",
      "amount_in_cents": 15000,
      "currency": "GTQ",
      "charge_type": "one_time",
      "quantity": 1,
      "payment_method_types": [],
      "available_installments": [6]
    }
  ]
}
```

Para que el comprador elija entre varias opciones, envía una lista como `available_installments: [3, 6, 12]`. Para ocultar cuotas, envía `available_installments: []`.

El parámetro `installments` aplica solo en endpoints de cobro directo que lo incluyan, como `POST /terminal_session_commands`, donde tu sistema escoge la cantidad de cuotas. Las cuotas dependen de la moneda, la cuenta, el banco/emisor y la tarjeta del comprador; si la tarjeta no soporta la opción elegida, el cobro puede fallar con `unsupported_installments`.

Reference: https://docs.recurrente.com/referencia-api/api-reference/checkouts/create-checkout

## Authentication

- `X-SECRET-KEY` header (required) — Tu clave secreta de API. Una llave de cuenta (`sk_live_...`, `sk_test_...`) opera sobre su propia cuenta y, con `X-ACCOUNT-ID`, sobre sus cuentas conectadas. La llave también fija el ambiente: una `sk_test_` solo lista y resuelve objetos de prueba (`live_mode: false`) y una `sk_live_` solo objetos reales. Un ID del otro ambiente responde `404` (`401` en `/customers`). Una llave de organización (`sk_org_live_...`, `sk_org_test_...`) alcanza todas las cuentas de una organización y solo sirve para leer: saldos, movimientos y reportes. Para operar sobre una cuenta debe nombrarla con `X-ACCOUNT-ID`; omitirlo en una lectura devuelve todas las cuentas de la organización. Cualquier otro endpoint responde `403` con `code: organization_key_unsupported`.

## Request

### Body (application/json)

This endpoint expects an object.

- `items` (list of CheckoutsPostRequestBodyContentApplicationJsonSchemaItemsItems, optional) — Lista de productos/servicios a incluir en el checkout. Cada item puede usar `product_id` / `price_id` (producto existente) **o** los campos inline (`name`, `amount_in_cents`, `currency`, …). Los dos modos son excluyentes para un mismo item.
- `mode` (enum, optional) — (Opcional) Modo del checkout. Envía `setup` para tokenizar una tarjeta sin cobrarla.
  - Allowed values: `setup`
- `success_url` (string, optional) — (Opcional) URL a dónde dirigir al comprador después de un pago exitoso
- `cancel_url` (string, optional) — (Opcional) URL a dónde dirigir al comprador cuando abandona el checkout. Admite HTTP, HTTPS y deep links de aplicaciones (por ejemplo, miapp://cancelar).
- `bank_transfer_memo` (string, optional) — (Opcional) Referencia que debe copiar el pagador al hacer una transferencia bancaria. Recurrente la normaliza a letras y números en mayúscula, sin espacios, acentos ni puntuación, y rechaza valores que sean iguales, contengan o estén contenidos en otra referencia activa de la cuenta. Si la omites, Recurrente genera una referencia legible a partir del nombre del pagador y le agrega un sufijo único.
- `clave_enabled` (boolean, optional, default: true) — (Opcional) Si el checkout ofrece Clave, la billetera con la que el comprador paga con sus tarjetas guardadas tras confirmar un código por WhatsApp o email. Envía `false` para que este checkout muestre solo el formulario de tarjeta y los demás métodos de pago: sin tarjetas guardadas, sin oferta de código y sin botón de Clave en el checkout embebido. La tarjeta con la que se pague tampoco se guarda en Clave. No quita los demás métodos de pago: Balance Recurrente sigue disponible si está habilitado, y el comprador entra a su cuenta de Recurrente para usarlo, no con un código de Clave.
- `user_id` (string, optional) — (Opcional) ID del usuario a quien pertenece el checkout. Prepopula los campos de información de usuario (nombre, email y teléfono del cliente si existe en tu cuenta).
- `customer_id` (string, optional) — (Opcional) ID del cliente en tu cuenta. Prepopula los campos de información de usuario (nombre, email y teléfono guardado del cliente). Si envías `customer_id` y `user_id`, se usa `customer_id`.
- `metadata` (Metadata, optional) — (Opcional) Metadata del checkout.
- `expires_at` (datetime, optional) — (Opcional) Fecha en la que quieres que el checkout expire, en formato ISO 8601
- `discount_code` (string, optional) — (Opcional) Código de descuento/cupón a aplicar al checkout
- `application_fee_amount` (integer, optional) — (Opcional, solo LIVE) Comisión de plataforma en centavos, para pagos únicos. Requiere cobrar a nombre de una cuenta conectada (header `X-ACCOUNT-ID`): cuando el cobro se completa, Recurrente transfiere este monto del balance de la cuenta conectada al de tu plataforma. La comisión se puede revertir al reembolsar con `refund_application_fee: true`, y se incluye en la facturación diaria de comisiones (DTE) si la conexión la tiene habilitada. No se puede combinar con `application_fee_percent` ni con un `transfer_setups` de `purpose: platform_commission`.
- `application_fee_percent` (double, optional) — (Opcional, solo LIVE) Comisión de plataforma como porcentaje del total de cada factura (0–100, hasta 2 decimales), para suscripciones. Requiere cobrar a nombre de una cuenta conectada (header `X-ACCOUNT-ID`): en cada cobro exitoso, Recurrente transfiere ese porcentaje del balance de la cuenta conectada al de tu plataforma mientras la suscripción esté activa. No se puede combinar con `application_fee_amount` ni con un `transfer_setups` de `purpose: platform_commission`.
- `transfer_setups` (list of CheckoutsPostRequestBodyContentApplicationJsonSchemaTransferSetupsItems, optional) — (Opcional, solo LIVE) Transferencias automáticas para enrutar fondos a otras cuentas de Recurrente (modelo destino: tú eres el comercio de registro y envías el neto a una cuenta conectada). En pagos únicos envía `amount_in_cents`: un monto fijo que se transfiere una vez, cuando el cobro se completa. En suscripciones envía `amount_percent`: un porcentaje del total de cada factura, que se transfiere en cada cobro exitoso mientras la suscripción esté activa. Para cobrar una comisión de plataforma usa `application_fee_amount` / `application_fee_percent` en su lugar.

## Response

### 201

Checkout creado exitosamente

- `id` (string, required) — ID único del checkout
- `status` (enum, required) — Estado del checkout
  - Allowed values: `unpaid`, `paid`, `payment_in_progress`, `expired`
- `items` (list of CheckoutItem, required) — Colección completa de filas mutables del checkout. No incluye descuentos, envío, fees ni prorrateos derivados.
- `bank_transfer_memo` (string, optional, nullable) — Referencia normalizada propuesta por la integración. Es null cuando Recurrente generará la referencia al iniciar el pago por transferencia.
- `total_in_cents` (integer, optional) — Monto total en centavos (después de descuentos)
- `subtotal_in_cents` (integer, optional) — Monto subtotal en centavos (antes de descuentos)
- `discount` (CheckoutsPostResponsesContentApplicationJsonSchemaDiscount, optional, nullable) — Descuento aplicado al checkout (null si no hay descuento)
- `currency` (enum, optional) — Moneda del checkout
  - Allowed values: `GTQ`, `USD`
- `payment_method_types` (list of enum, optional) — Métodos de pago que se le ofrecerán al comprador en este checkout, ya resueltos según la configuración del producto/cuenta, la moneda y el tipo de cobro: `card` (tarjeta, pago de contado), `bank_transfer` (transferencia bancaria), `stablecoins` (dólares digitales), `balance` (Balance Recurrente), `akisi` (efectivo en Akisí; solo cuentas habilitadas, cobros únicos en GTQ con precio fijo y cuentas fuera de Sandbox). Las cuotas se exponen por separado en `available_installments`; `card` indica pago de contado, así que un checkout puede ofrecer cuotas (`available_installments` no vacío) sin incluir `card`.
  - Allowed values: `card`, `bank_transfer`, `stablecoins`, `balance`, `akisi`
- `available_installments` (list of integer, optional) — Opciones de cuotas (en meses) disponibles en este checkout, independientes de `payment_method_types`. Vacío si no se ofrecen cuotas.
- `live_mode` (boolean, optional) — Si el checkout está en modo producción (true) o prueba (false)
- `amount_set_in_browser` (boolean, optional) — El monto lo fijó el navegador del comprador. Solo en checkouts creados por el botón de Clave en el sitio del comercio, con ítems con monto inline y sin firma del servidor. Compáralo con tu pedido antes de entregar.
- `clave_enabled` (boolean, optional) — Si el checkout ofrece Clave (tarjetas guardadas del comprador). `false` cuando se creó con `clave_enabled` en `false`.
- `success_url` (string, optional) — URL de redirección en caso de pago exitoso
- `cancel_url` (string, optional) — URL de redirección en caso de cancelación
- `expires_at` (datetime, optional) — Fecha de expiración del checkout
- `created_at` (datetime, optional) — Fecha de creación
- `metadata` (Metadata, optional) — Metadata personalizada del checkout
- `custom_fields` (list of CheckoutCustomFieldValue, optional) — Valores recolectados de los campos personalizados. Si el checkout tiene múltiples productos, cada producto contribuye sus propias entradas — la `key` puede repetirse entre productos. Usa `field_id` como identificador canónico al reconciliar valores.
- `transfer_setups` (list of TransferSetup, optional) — Configuraciones de transferencia asociadas
- `application_fee_amount` (integer, optional, nullable) — Comisión de plataforma en centavos (pagos únicos): la suma de las transferencias de comisión del checkout. `null` cuando no hay comisión.
- `application_fee_percent` (double, optional, nullable) — Comisión de plataforma como porcentaje del total de cada factura (suscripciones). `null` cuando no hay comisión.
- `latest_intent` (CheckoutsPostResponsesContentApplicationJsonSchemaLatestIntent, optional, nullable) — Último intent unificado asociado. Su `id` usa el prefijo `in_…`.
- `payment` (CheckoutsPostResponsesContentApplicationJsonSchemaPayment, optional, nullable) — Información del pago (si está pagado)
- `payment_method` (CheckoutsPostResponsesContentApplicationJsonSchemaPaymentMethod, optional, nullable) — Método de pago utilizado
- `checkout_url` (string, optional) — URL del checkout donde el usuario puede pagar

## Errors

### 400 Bad Request Error

Error de validación

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

### 422 Unprocessable Entity Error

El total supera lo que la cuenta puede procesar sin verificarse (`amount_exceeds_unverified_limit`). No se crea el checkout: nadie podría pagarlo mientras la cuenta siga sin verificar.

- `message` (string, optional) — Mensaje de error
- `code` (string, optional) — Código estable legible por máquinas, cuando aplica
- `refund_id` (string, optional) — ID del reembolso relacionado cuando aplica
- `endpoint` (string, optional) — Acción de API rechazada, cuando aplica
- `errors` (ErrorErrors, optional) — Detalles de errores por campo

## Types

### CheckoutsPostRequestBodyContentApplicationJsonSchemaItemsItems

- `product_id` (string, optional) — ID de un producto existente en tu cuenta (lo obtienes al crear el producto o desde `GET /products`). Cuando lo envías, **no es necesario** incluir `name`, `amount_in_cents`, `currency` ni los demás campos inline — el checkout usa el primer precio del producto. Si el producto tiene múltiples precios, usa `price_id` para elegir uno específico.
- `price_id` (string, optional) — ID de un precio específico (lo obtienes en `prices[].id` al crear u obtener un producto). Úsalo cuando un mismo producto tenga varios precios y quieras elegir cuál cobrar. Tiene precedencia sobre `product_id` si envías ambos.
- `quantity` (integer, optional, default: 1) — (Opcional) Cantidad. Si no incluyes una, el default es 1. El valor mínimo es 1 y el valor máximo es 9. Aplica tanto si usas `product_id`/`price_id` como si envías detalles inline.
- `metadata` (Metadata, optional) — (Opcional) Metadata persistida en esta fila del checkout. Dos filas pueden usar el mismo `price_id` y mantener metadata distinta.
- `tax_category` (enum, optional, default: good) — Clasificación para FEL: good (bien) o service (servicio). Cada ítem conserva su clasificación en facturas mixtas. Solo modo inline; con product_id o price_id se usa la clasificación del producto.
  - Allowed values: `good`, `service`
- `name` (string, optional) — (Solo modo inline) El nombre del producto. Ignorado si envías `product_id` o `price_id`.
- `currency` (enum, optional) — (Solo modo inline) La moneda a cobrar.
  - Allowed values: `GTQ`, `USD`
- `amount_in_cents` (integer, optional) — (Solo modo inline) Monto a cobrar en centavos. El total del checkout debe ser al menos 500 para GTQ (Q5) o 100 para USD ($1); un ítem individual puede ser menor si el total cumple el mínimo.
- `phone_requirement` (enum, optional, default: optional) — (Solo modo inline, opcional) Requerimiento de teléfono para el formulario de checkout.
  - Allowed values: `none`, `optional`, `required`
- `address_requirement` (enum, optional, default: none) — (Solo modo inline, opcional) Requerimiento de dirección para el formulario de checkout.
  - Allowed values: `none`, `optional`, `required`
- `billing_info_requirement` (enum, optional, default: optional) — (Solo modo inline, opcional) Requerimiento de información fiscal (NIT) para el formulario de checkout.
  - Allowed values: `none`, `optional`, `required`
- `image_url` (string, optional) — (Solo modo inline, opcional) URL de la imagen del producto.
- `charge_type` (enum, optional) — (Solo modo inline) Tipo de cargo.
  - Allowed values: `one_time`, `recurring`
- `billing_interval` (enum, optional) — (Solo modo inline, para suscripciones) Intervalo de facturación.
  - Allowed values: `day`, `week`, `month`, `year`
- `billing_interval_count` (integer, optional) — (Solo modo inline, para suscripciones) Cada cuántos intervalos se cobra.
- `periods_before_automatic_cancellation` (integer, optional) — (Solo modo inline, opcional, para suscripciones) Número de períodos antes de cancelar automáticamente.
- `free_trial_interval` (enum, optional) — (Solo modo inline, opcional, para suscripciones) Intervalo del período de prueba gratuito.
  - Allowed values: `week`, `month`, `year`
- `free_trial_interval_count` (integer, optional) — (Solo modo inline, opcional, para suscripciones) Duración del período de prueba gratuito.
- `proration_behavior` (enum, optional, default: none) — (Solo modo inline, opcional, para suscripciones mensuales) Controla el primer cobro cuando la suscripción se crea un día distinto al `billing_cycle_anchor_day`. `create_prorations` cobra solo los días restantes hasta el día de cobro (como ítem de crédito en el checkout); `none` cobra el monto completo. Ignorado si hay período de prueba gratuito.
  - Allowed values: `none`, `create_prorations`
- `billing_cycle_anchor_day` (integer, optional) — (Solo modo inline, opcional, para suscripciones mensuales) Día del mes (1–31) en que ocurrirán los cobros recurrentes. Combínalo con `proration_behavior` o `defer_to_billing_day` para controlar la fecha del primer cobro. Si el mes tiene menos días, se cobra el último día.
- `defer_to_billing_day` (boolean, optional, default: false) — (Solo modo inline, opcional, para suscripciones mensuales) Si es `true`, difiere el primer cobro hasta la próxima ocurrencia de `billing_cycle_anchor_day` (solo se guarda el método de pago al crear). Alternativa a `proration_behavior: create_prorations` cuando no quieres cobrar nada hasta el día de cobro.
- `has_dynamic_pricing` (boolean, optional, default: false) — (Solo modo inline, opcional) Indica si el producto debe usar precio dinámico. El precio se convierte en el 'monto a recibir' neto por el comercio. Disponible solo para pagos únicos.
- `payment_method_types` (list of enum, optional) — (Solo modo inline, opcional) Métodos de pago habilitados para este ítem: `card` (tarjeta, pago de contado), `bank_transfer` (transferencia bancaria), `stablecoins` (dólares digitales), `balance` (Balance Recurrente), `akisi` (efectivo en Akisí; solo cuentas habilitadas, cobros únicos en GTQ con precio fijo y cuentas fuera de Sandbox). Al enviarlo, el ítem usa su propia configuración en vez de heredar la de la cuenta; los valores no reconocidos se ignoran. Las cuotas son un eje aparte (`available_installments`): `card` controla el pago de contado con tarjeta, no las cuotas. Para que el comprador solo pueda pagar en cuotas, omite `card` y envía `available_installments`.
  - Allowed values: `card`, `bank_transfer`, `stablecoins`, `balance`, `akisi`
- `available_installments` (list of enum, optional) — (Solo modo inline, opcional) Opciones de cuotas (en meses) que se mostrarán en el checkout, independientes de `payment_method_types`. Solo aplica a `GTQ` y requiere que la cuenta tenga pagos con tarjeta habilitados. Usa `[]` para ocultar cuotas, o una lista como `[3]` para mostrar solo esa opción. Si envías `product_id` o `price_id`, este campo no sobreescribe el producto existente; configura las cuotas en el producto con `POST /products` o `PATCH /products`.
  - Allowed values: `3`, `6`, `12`, `18`

### Metadata

### CheckoutsPostRequestBodyContentApplicationJsonSchemaTransferSetupsItems

- `amount_in_cents` (integer, optional) — Monto fijo en centavos a transferir (solo pagos únicos). La suma de todas las transferencias no puede exceder el monto neto disponible después de fees, FEL e IVA.
- `amount_percent` (double, optional) — Porcentaje del total de cada factura a transferir (solo suscripciones), entre 0 y 100 con hasta 2 decimales. Al crear el checkout se valida que el porcentaje quepa en el monto neto disponible después de fees, FEL e IVA.
- `recipient_id` (string, optional) — ID de la cuenta de Recurrente que recibe los fondos (típicamente una cuenta conectada). No es una cuenta bancaria: los fondos se acreditan al balance de Recurrente de esa cuenta. Si se omite, se usa tu propia cuenta.
- `purpose` (enum, optional, default: fund_split) — Legacy — omítelo. `fund_split` (el valor predeterminado) es una distribución ordinaria de fondos. `platform_commission` marca la transferencia como comisión de plataforma; para eso usa `application_fee_amount` / `application_fee_percent`, que crean la misma transferencia sin que tengas que armarla a mano. Se sigue aceptando por compatibilidad y no se puede combinar con esos parámetros.
  - Allowed values: `fund_split`, `platform_commission`

### CheckoutItem

- `id` (string, required) — ID estable de esta fila del checkout. Úsalo para modificarla o eliminarla.
- `price_id` (string, required) — ID del precio asociado. Puede repetirse en varias filas.
- `quantity` (integer, required) — Cantidad absoluta de esta fila.
- `metadata` (Metadata, required)
- `variant` (ProductVariant, optional, nullable) — La variante que compra esta fila cuando el precio es de una variante; `null` para un producto sin variantes.

### CheckoutsPostResponsesContentApplicationJsonSchemaDiscount

Descuento aplicado al checkout (null si no hay descuento)

- `amount_in_cents` (integer, optional) — Monto del descuento en centavos
- `coupon` (Coupon, optional)

### CheckoutCustomFieldValue

Valor recolectado de un campo personalizado al pagar.

- `field_id` (string, optional) — Identificador canónico del campo (estable y único por producto). Úsalo para reconciliar valores; en checkouts con múltiples productos, dos entradas pueden tener la misma `key` pero distinto `field_id`.
- `key` (string, optional) — Identificador legible definido por el comerciante. Puede repetirse entre productos en el mismo checkout.
- `type` (enum, optional)
  - Allowed values: `text`, `numeric`, `dropdown`
- `value` (string, optional)

### TransferSetup

Transferencia automática de fondos a otra cuenta de Recurrente. Con `amount_in_cents` (pagos únicos) se ejecuta una vez al completarse el cobro; con `amount_percent` (suscripciones) se ejecuta en cada cobro exitoso, transfiriendo ese porcentaje del total de la factura.

- `id` (string, optional) — ID de la configuración de transferencia
- `status` (enum, optional) — En pagos únicos: `pending` mientras el cobro no se completa y `completed` cuando la transferencia se ejecutó. `in_review` indica que el monto está reservado por revisión de riesgo. Un reembolso del pago debe esperar a que se resuelva esa revisión. En suscripciones la configuración queda `pending` mientras la suscripción está activa. `cancelled` si la revisión rechazó el envío, o si el checkout, la suscripción o un reembolso canceló el setup antes de ejecutarlo; `reversed` si un reembolso devolvió una transferencia ya completada.
  - Allowed values: `pending`, `in_review`, `completed`, `cancelled`, `reversed`
- `amount_in_cents` (integer, optional, nullable) — Monto fijo en centavos a transferir (pagos únicos). No puede exceder el monto neto disponible después de fees, FEL e IVA.
- `amount_percent` (double, optional, nullable) — Porcentaje del total de cada factura a transferir (suscripciones).
- `currency` (string, optional) — Moneda
- `recipient_id` (string, optional) — ID de la cuenta de Recurrente que recibe los fondos (no es una cuenta bancaria).
- `purpose` (enum, optional, default: fund_split) — Qué representa la transferencia. `fund_split` (el valor predeterminado) es una distribución ordinaria de fondos: enruta parte del cobro a otra cuenta, sin más consecuencias. `platform_commission` marca la transferencia como la comisión que una cuenta conectada paga a su plataforma — es lo que crean `application_fee_amount` / `application_fee_percent` — y cambia tres comportamientos: solo puede fluir de la cuenta conectada hacia su plataforma (sobre una conexión activa), es la única que un reembolso revierte con `refund_application_fee: true`, y se incluye en la facturación diaria de comisiones (DTE) cuando la conexión la tiene habilitada.
  - Allowed values: `fund_split`, `platform_commission`

### CheckoutsPostResponsesContentApplicationJsonSchemaLatestIntent

Último intent unificado asociado. Su `id` usa el prefijo `in_…`.

- `id` (string, optional)
- `type` (string, optional)
- `created_at` (datetime, optional)
- `data` (CheckoutsPostResponsesContentApplicationJsonSchemaLatestIntentData, optional)

### CheckoutsPostResponsesContentApplicationJsonSchemaPayment

Información del pago (si está pagado)

- `id` (string, optional) — ID del pago
- `paymentable` (CheckoutsPostResponsesContentApplicationJsonSchemaPaymentPaymentable, optional)

### CheckoutsPostResponsesContentApplicationJsonSchemaPaymentMethod

Método de pago utilizado

- `id` (string, optional) — ID del método de pago
- `type` (string, optional) — Tipo de método de pago
- `card` (CheckoutsPostResponsesContentApplicationJsonSchemaPaymentMethodCard, optional)
- `address` (Address, optional)
- `phone_number` (string, optional, nullable) — Número de teléfono asociado al método de pago

### ErrorErrors

Detalles de errores por campo

### ProductVariant

Una combinación vendible de las opciones del producto (el modelo de variantes de Shopify). Su precio es un `Price` del producto; la línea del checkout apunta a ese `price_id` y el webhook trae la variante en `items[].variant`.

- `id` (string, optional)
- `product_id` (string, optional) — El producto al que pertenece esta combinación. El SKU es único por producto, no por cuenta, así que es lo que permite resolver una fila de la lista.
- `status` (enum, optional)
  - Allowed values: `active`, `archived`
- `title` (string, optional) — Los valores unidos por " / ".
- `option_values` (list of string, optional)
- `sku` (string, optional, nullable)
- `price_id` (string, optional) — El precio de esta variante.
- `amount_in_cents` (integer, optional)
- `currency` (string, optional)
- `inventory_quantity` (integer, optional, nullable) — Existencias de esta variante. `null` es ilimitado. Baja con cada venta pagada de esta variante y puede quedar en negativo si se vendió más de lo que había; un número escrito aquí es cero o más.
- `low_stock_threshold` (integer, optional, nullable) — Desde qué cantidad se considera baja esta variante. `null` usa el valor por defecto de la cuenta.

### Coupon

- `id` (string, optional) — ID único del cupón
- `name` (string, optional) — Nombre o código del cupón
- `discount_mode` (enum, optional) — Tipo de descuento
  - Allowed values: `code`, `bank`, `custom_bins`
- `display_name` (string, optional, nullable) — Nombre visible para el cliente (usado en modo custom_bins)
- `amount_off_in_cents` (integer, optional, nullable) — Descuento fijo en centavos
- `percent_off` (double, optional, nullable) — Porcentaje de descuento
- `automatically_applies` (boolean, optional) — Si el descuento se aplica automáticamente en checkouts de tienda
- `max_redemptions` (integer, optional, nullable) — Número máximo de usos
- `times_redeemed` (integer, optional) — Número de veces que se ha redimido el descuento
- `currency` (string, optional, nullable) — Moneda del descuento fijo
- `duration` (enum, optional) — Duración del descuento para suscripciones
  - Allowed values: `once`, `repeating`, `forever`
- `duration_in_payments` (integer, optional, nullable) — Cuántos pagos de la suscripción llevan el descuento (solo con `duration` = `repeating`)
- `minimum_amount_in_cents` (integer, optional, nullable) — Compra mínima en centavos, sobre los productos a los que aplica (sin envío)
- `once_per_customer` (boolean, optional) — Si cada cliente puede usar el cupón una sola vez
- `product_ids` (list of string, optional) — IDs de los productos a los que aplica. Vacío si aplica a todos.
- `starts_at` (datetime, optional, nullable) — Desde cuándo se puede usar el cupón
- `expires_at` (datetime, optional, nullable) — Fecha de expiración
- `status` (string, optional) — Estado del cupón

### CheckoutsPostResponsesContentApplicationJsonSchemaLatestIntentData

- `auth_code` (string, optional, nullable)

### CheckoutsPostResponsesContentApplicationJsonSchemaPaymentPaymentable

- `type` (string, optional) — Tipo de elemento pagable
- `id` (string, optional) — ID del elemento pagable
- `tax_name` (string, optional, nullable) — Nombre fiscal del comprador
- `tax_id` (string, optional, nullable) — ID fiscal del comprador
- `address` (Address, optional)
- `phone_number` (string, optional, nullable) — Número de teléfono del comprador

### CheckoutsPostResponsesContentApplicationJsonSchemaPaymentMethodCard

- `last4` (string, optional) — Últimos 4 dígitos de la tarjeta
- `expiration_month` (integer, optional) — Mes de expiración
- `expiration_year` (integer, optional) — Año de expiración
- `network` (string, optional) — Red de la tarjeta
- `issuer_name` (string, optional, nullable) — Nombre del banco emisor
- `wallet` (enum, optional) — Billetera con la que se pagó. Solo presente en pagos con billetera; en ese caso issuer_name no viene.
  - Allowed values: `apple_pay`

### Address

- `address_line_1` (string, optional, nullable) — Línea de dirección 1
- `address_line_2` (string, optional, nullable) — Línea de dirección 2
- `city` (string, optional, nullable) — Ciudad
- `region` (string, optional, nullable) — Región o departamento
- `country` (string, optional, nullable) — País
- `zip_code` (string, optional, nullable) — Código postal

## Examples

### Con un producto ya creado

**Request**

```json
{
  "items": [
    {
      "product_id": "prod_1234567",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Con un producto ya creado
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "product_id": "prod_1234567",
            "quantity": 1
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Con un producto ya creado
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"product_id":"prod_1234567","quantity":1}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Con un producto ya creado
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Con un producto ya creado
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}"

response = http.request(request)
puts response.read_body
```

```java Con un producto ya creado
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")
  .asString();
```

```php Con un producto ya creado
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "product_id": "prod_1234567",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Con un producto ya creado
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Con un producto ya creado
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "product_id": "prod_1234567",
      "quantity": 1
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Con un precio específico

**Request**

```json
{
  "items": [
    {
      "price_id": "price_rky4dog7",
      "quantity": 1
    }
  ]
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Con un precio específico
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = { "items": [
        {
            "price_id": "price_rky4dog7",
            "quantity": 1
        }
    ] }
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Con un precio específico
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"price_id":"price_rky4dog7","quantity":1}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Con un precio específico
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"price_id\": \"price_rky4dog7\",\n      \"quantity\": 1\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Con un precio específico
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"price_id\": \"price_rky4dog7\",\n      \"quantity\": 1\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java Con un precio específico
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"price_id\": \"price_rky4dog7\",\n      \"quantity\": 1\n    }\n  ]\n}")
  .asString();
```

```php Con un precio específico
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "price_id": "price_rky4dog7",
      "quantity": 1
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Con un precio específico
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"price_id\": \"price_rky4dog7\",\n      \"quantity\": 1\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Con un precio específico
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["items": [
    [
      "price_id": "price_rky4dog7",
      "quantity": 1
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Con código de descuento

**Request**

```json
{
  "items": [
    {
      "product_id": "prod_1234567",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "discount_code": "WELCOME10"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Con código de descuento
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "product_id": "prod_1234567",
            "quantity": 1
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar",
    "discount_code": "WELCOME10"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Con código de descuento
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"product_id":"prod_1234567","quantity":1}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar","discount_code":"WELCOME10"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Con código de descuento
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"discount_code\": \"WELCOME10\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Con código de descuento
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"discount_code\": \"WELCOME10\"\n}"

response = http.request(request)
puts response.read_body
```

```java Con código de descuento
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"discount_code\": \"WELCOME10\"\n}")
  .asString();
```

```php Con código de descuento
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "product_id": "prod_1234567",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "discount_code": "WELCOME10"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Con código de descuento
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"product_id\": \"prod_1234567\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"discount_code\": \"WELCOME10\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Con código de descuento
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "product_id": "prod_1234567",
      "quantity": 1
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "discount_code": "WELCOME10"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Con detalles inline (sin producto previo)

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Camiseta talla M",
      "currency": "GTQ",
      "amount_in_cents": 15000
    },
    {
      "quantity": 1,
      "name": "Costo de Envío",
      "currency": "GTQ",
      "amount_in_cents": 100
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Con detalles inline (sin producto previo)
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Camiseta talla M",
            "currency": "GTQ",
            "amount_in_cents": 15000
        },
        {
            "quantity": 1,
            "name": "Costo de Envío",
            "currency": "GTQ",
            "amount_in_cents": 100
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Con detalles inline (sin producto previo)
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Camiseta talla M","currency":"GTQ","amount_in_cents":15000},{"quantity":1,"name":"Costo de Envío","currency":"GTQ","amount_in_cents":100}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Con detalles inline (sin producto previo)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Camiseta talla M\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000\n    },\n    {\n      \"quantity\": 1,\n      \"name\": \"Costo de Envío\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 100\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Con detalles inline (sin producto previo)
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Camiseta talla M\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000\n    },\n    {\n      \"quantity\": 1,\n      \"name\": \"Costo de Envío\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 100\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}"

response = http.request(request)
puts response.read_body
```

```java Con detalles inline (sin producto previo)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Camiseta talla M\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000\n    },\n    {\n      \"quantity\": 1,\n      \"name\": \"Costo de Envío\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 100\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")
  .asString();
```

```php Con detalles inline (sin producto previo)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Camiseta talla M",
      "currency": "GTQ",
      "amount_in_cents": 15000
    },
    {
      "quantity": 1,
      "name": "Costo de Envío",
      "currency": "GTQ",
      "amount_in_cents": 100
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Con detalles inline (sin producto previo)
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Camiseta talla M\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000\n    },\n    {\n      \"quantity\": 1,\n      \"name\": \"Costo de Envío\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 100\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Con detalles inline (sin producto previo)
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Camiseta talla M",
      "currency": "GTQ",
      "amount_in_cents": 15000
    ],
    [
      "quantity": 1,
      "name": "Costo de Envío",
      "currency": "GTQ",
      "amount_in_cents": 100
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Pago con tarjeta sin cuotas

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Pago de contado",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": [
        "card"
      ],
      "available_installments": []
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Pago con tarjeta sin cuotas
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Pago de contado",
            "currency": "GTQ",
            "amount_in_cents": 15000,
            "charge_type": "one_time",
            "payment_method_types": ["card"],
            "available_installments": []
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Pago con tarjeta sin cuotas
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Pago de contado","currency":"GTQ","amount_in_cents":15000,"charge_type":"one_time","payment_method_types":["card"],"available_installments":[]}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Pago con tarjeta sin cuotas
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago de contado\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\"\n      ],\n      \"available_installments\": []\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Pago con tarjeta sin cuotas
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago de contado\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\"\n      ],\n      \"available_installments\": []\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}"

response = http.request(request)
puts response.read_body
```

```java Pago con tarjeta sin cuotas
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago de contado\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\"\n      ],\n      \"available_installments\": []\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")
  .asString();
```

```php Pago con tarjeta sin cuotas
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Pago de contado",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": [
        "card"
      ],
      "available_installments": []
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Pago con tarjeta sin cuotas
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago de contado\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\"\n      ],\n      \"available_installments\": []\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Pago con tarjeta sin cuotas
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Pago de contado",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": ["card"],
      "available_installments": []
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Solo 3 cuotas

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Pago en 3 cuotas",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": [],
      "available_installments": [
        3
      ]
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Solo 3 cuotas
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Pago en 3 cuotas",
            "currency": "GTQ",
            "amount_in_cents": 15000,
            "charge_type": "one_time",
            "payment_method_types": [],
            "available_installments": [3]
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Solo 3 cuotas
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Pago en 3 cuotas","currency":"GTQ","amount_in_cents":15000,"charge_type":"one_time","payment_method_types":[],"available_installments":[3]}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Solo 3 cuotas
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago en 3 cuotas\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [],\n      \"available_installments\": [\n        3\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Solo 3 cuotas
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago en 3 cuotas\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [],\n      \"available_installments\": [\n        3\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}"

response = http.request(request)
puts response.read_body
```

```java Solo 3 cuotas
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago en 3 cuotas\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [],\n      \"available_installments\": [\n        3\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")
  .asString();
```

```php Solo 3 cuotas
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Pago en 3 cuotas",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": [],
      "available_installments": [
        3
      ]
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Solo 3 cuotas
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Pago en 3 cuotas\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 15000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [],\n      \"available_installments\": [\n        3\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Solo 3 cuotas
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Pago en 3 cuotas",
      "currency": "GTQ",
      "amount_in_cents": 15000,
      "charge_type": "one_time",
      "payment_method_types": [],
      "available_installments": [3]
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Tarjeta, Balance y cuotas de 3 y 18 meses

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Plan completo",
      "currency": "GTQ",
      "amount_in_cents": 150000,
      "charge_type": "one_time",
      "payment_method_types": [
        "card",
        "balance"
      ],
      "available_installments": [
        3,
        18
      ]
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Tarjeta, Balance y cuotas de 3 y 18 meses
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Plan completo",
            "currency": "GTQ",
            "amount_in_cents": 150000,
            "charge_type": "one_time",
            "payment_method_types": ["card", "balance"],
            "available_installments": [3, 18]
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar"
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Tarjeta, Balance y cuotas de 3 y 18 meses
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Plan completo","currency":"GTQ","amount_in_cents":150000,"charge_type":"one_time","payment_method_types":["card","balance"],"available_installments":[3,18]}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Tarjeta, Balance y cuotas de 3 y 18 meses
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Plan completo\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 150000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\",\n        \"balance\"\n      ],\n      \"available_installments\": [\n        3,\n        18\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Tarjeta, Balance y cuotas de 3 y 18 meses
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Plan completo\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 150000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\",\n        \"balance\"\n      ],\n      \"available_installments\": [\n        3,\n        18\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}"

response = http.request(request)
puts response.read_body
```

```java Tarjeta, Balance y cuotas de 3 y 18 meses
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Plan completo\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 150000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\",\n        \"balance\"\n      ],\n      \"available_installments\": [\n        3,\n        18\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}")
  .asString();
```

```php Tarjeta, Balance y cuotas de 3 y 18 meses
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Plan completo",
      "currency": "GTQ",
      "amount_in_cents": 150000,
      "charge_type": "one_time",
      "payment_method_types": [
        "card",
        "balance"
      ],
      "available_installments": [
        3,
        18
      ]
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Tarjeta, Balance y cuotas de 3 y 18 meses
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Plan completo\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 150000,\n      \"charge_type\": \"one_time\",\n      \"payment_method_types\": [\n        \"card\",\n        \"balance\"\n      ],\n      \"available_installments\": [\n        3,\n        18\n      ]\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Tarjeta, Balance y cuotas de 3 y 18 meses
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Plan completo",
      "currency": "GTQ",
      "amount_in_cents": 150000,
      "charge_type": "one_time",
      "payment_method_types": ["card", "balance"],
      "available_installments": [3, 18]
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Dividir el pago con otra cuenta

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Venta marketplace",
      "currency": "GTQ",
      "amount_in_cents": 50000
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    {
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    }
  ]
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Dividir el pago con otra cuenta
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Venta marketplace",
            "currency": "GTQ",
            "amount_in_cents": 50000
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar",
    "transfer_setups": [
        {
            "amount_in_cents": 45000,
            "recipient_id": "ac_123456"
        }
    ]
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Dividir el pago con otra cuenta
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Venta marketplace","currency":"GTQ","amount_in_cents":50000}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar","transfer_setups":[{"amount_in_cents":45000,"recipient_id":"ac_123456"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Dividir el pago con otra cuenta
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta marketplace\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 50000\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Dividir el pago con otra cuenta
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta marketplace\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 50000\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java Dividir el pago con otra cuenta
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta marketplace\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 50000\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")
  .asString();
```

```php Dividir el pago con otra cuenta
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Venta marketplace",
      "currency": "GTQ",
      "amount_in_cents": 50000
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    {
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Dividir el pago con otra cuenta
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta marketplace\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 50000\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_in_cents\": 45000,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Dividir el pago con otra cuenta
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Venta marketplace",
      "currency": "GTQ",
      "amount_in_cents": 50000
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    [
      "amount_in_cents": 45000,
      "recipient_id": "ac_123456"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Dividir una suscripción con otra cuenta

**Request**

```json
{
  "items": [
    {
      "price_id": "price_mensual123",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    {
      "amount_percent": 90,
      "recipient_id": "ac_123456"
    }
  ]
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Dividir una suscripción con otra cuenta
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "price_id": "price_mensual123",
            "quantity": 1
        }
    ],
    "success_url": "https://tusitio.com/exito",
    "cancel_url": "https://tusitio.com/cancelar",
    "transfer_setups": [
        {
            "amount_percent": 90,
            "recipient_id": "ac_123456"
        }
    ]
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Dividir una suscripción con otra cuenta
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"price_id":"price_mensual123","quantity":1}],"success_url":"https://tusitio.com/exito","cancel_url":"https://tusitio.com/cancelar","transfer_setups":[{"amount_percent":90,"recipient_id":"ac_123456"}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Dividir una suscripción con otra cuenta
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_percent\": 90,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Dividir una suscripción con otra cuenta
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_percent\": 90,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java Dividir una suscripción con otra cuenta
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_percent\": 90,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}")
  .asString();
```

```php Dividir una suscripción con otra cuenta
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "price_id": "price_mensual123",
      "quantity": 1
    }
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    {
      "amount_percent": 90,
      "recipient_id": "ac_123456"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Dividir una suscripción con otra cuenta
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"success_url\": \"https://tusitio.com/exito\",\n  \"cancel_url\": \"https://tusitio.com/cancelar\",\n  \"transfer_setups\": [\n    {\n      \"amount_percent\": 90,\n      \"recipient_id\": \"ac_123456\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Dividir una suscripción con otra cuenta
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "price_id": "price_mensual123",
      "quantity": 1
    ]
  ],
  "success_url": "https://tusitio.com/exito",
  "cancel_url": "https://tusitio.com/cancelar",
  "transfer_setups": [
    [
      "amount_percent": 90,
      "recipient_id": "ac_123456"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobrar una comisión a una cuenta conectada

**Request**

```json
{
  "items": [
    {
      "quantity": 1,
      "name": "Venta del restaurante",
      "currency": "GTQ",
      "amount_in_cents": 10000
    }
  ],
  "application_fee_amount": 3250
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Cobrar una comisión a una cuenta conectada
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "quantity": 1,
            "name": "Venta del restaurante",
            "currency": "GTQ",
            "amount_in_cents": 10000
        }
    ],
    "application_fee_amount": 3250
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobrar una comisión a una cuenta conectada
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"quantity":1,"name":"Venta del restaurante","currency":"GTQ","amount_in_cents":10000}],"application_fee_amount":3250}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobrar una comisión a una cuenta conectada
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta del restaurante\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 10000\n    }\n  ],\n  \"application_fee_amount\": 3250\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobrar una comisión a una cuenta conectada
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta del restaurante\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 10000\n    }\n  ],\n  \"application_fee_amount\": 3250\n}"

response = http.request(request)
puts response.read_body
```

```java Cobrar una comisión a una cuenta conectada
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta del restaurante\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 10000\n    }\n  ],\n  \"application_fee_amount\": 3250\n}")
  .asString();
```

```php Cobrar una comisión a una cuenta conectada
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "quantity": 1,
      "name": "Venta del restaurante",
      "currency": "GTQ",
      "amount_in_cents": 10000
    }
  ],
  "application_fee_amount": 3250
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobrar una comisión a una cuenta conectada
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"quantity\": 1,\n      \"name\": \"Venta del restaurante\",\n      \"currency\": \"GTQ\",\n      \"amount_in_cents\": 10000\n    }\n  ],\n  \"application_fee_amount\": 3250\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobrar una comisión a una cuenta conectada
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "quantity": 1,
      "name": "Venta del restaurante",
      "currency": "GTQ",
      "amount_in_cents": 10000
    ]
  ],
  "application_fee_amount": 3250
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Cobrar una comisión recurrente a una cuenta conectada

**Request**

```json
{
  "items": [
    {
      "price_id": "price_mensual123",
      "quantity": 1
    }
  ],
  "application_fee_percent": 10
}
```

**Response**

```json
{
  "id": "ch_eegw9j5zgqoae3ms",
  "status": "unpaid",
  "items": [
    {
      "id": "it_eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBQT09IiwiZXhwIjpudWxsLCJwdXIiOiJjaGVja291dF9pdGVtIn19",
      "price_id": "price_rky4dog7",
      "quantity": 1,
      "metadata": {}
    }
  ],
  "checkout_url": "https://app.recurrente.com/checkout-session/ch_eegw9j5zgqoae3ms"
}
```

**SDK Code**

```python Cobrar una comisión recurrente a una cuenta conectada
import requests

url = "https://app.recurrente.com/api/checkouts"

payload = {
    "items": [
        {
            "price_id": "price_mensual123",
            "quantity": 1
        }
    ],
    "application_fee_percent": 10
}
headers = {
    "X-SECRET-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Cobrar una comisión recurrente a una cuenta conectada
const url = 'https://app.recurrente.com/api/checkouts';
const options = {
  method: 'POST',
  headers: {'X-SECRET-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"items":[{"price_id":"price_mensual123","quantity":1}],"application_fee_percent":10}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Cobrar una comisión recurrente a una cuenta conectada
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.recurrente.com/api/checkouts"

	payload := strings.NewReader("{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"application_fee_percent\": 10\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-SECRET-KEY", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Cobrar una comisión recurrente a una cuenta conectada
require 'uri'
require 'net/http'

url = URI("https://app.recurrente.com/api/checkouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-SECRET-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"application_fee_percent\": 10\n}"

response = http.request(request)
puts response.read_body
```

```java Cobrar una comisión recurrente a una cuenta conectada
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.recurrente.com/api/checkouts")
  .header("X-SECRET-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"application_fee_percent\": 10\n}")
  .asString();
```

```php Cobrar una comisión recurrente a una cuenta conectada
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.recurrente.com/api/checkouts', [
  'body' => '{
  "items": [
    {
      "price_id": "price_mensual123",
      "quantity": 1
    }
  ],
  "application_fee_percent": 10
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-SECRET-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Cobrar una comisión recurrente a una cuenta conectada
using RestSharp;

var client = new RestClient("https://app.recurrente.com/api/checkouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-SECRET-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"items\": [\n    {\n      \"price_id\": \"price_mensual123\",\n      \"quantity\": 1\n    }\n  ],\n  \"application_fee_percent\": 10\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Cobrar una comisión recurrente a una cuenta conectada
import Foundation

let headers = [
  "X-SECRET-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "items": [
    [
      "price_id": "price_mensual123",
      "quantity": 1
    ]
  ],
  "application_fee_percent": 10
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.recurrente.com/api/checkouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```