Contexto de checkout

Vincula el Bridge SDK a una sesión de checkout creada en el backend y lee el contexto completo del checkout — ítems con precio, moneda seleccionada, métodos de pago disponibles y las tarjetas guardadas del cliente — para renderizar un checkout dinámico dirigido por el servidor.

Tu backend es dueño del checkout. Crea una sesión de checkout con su clave secreta — asignando el precio a la oferta, seleccionando la moneda e identificando al cliente. El Bridge SDK luego se vincula a esa sesión en el navegador y lee su contexto: los ítems con precio, la moneda seleccionada, los métodos de pago disponibles del Merchant y las tarjetas guardadas del cliente.

Esto te permite renderizar una única interfaz de checkout dinámica, dirigida por completo por el servidor. El navegador nunca decide qué se cobra, en qué moneda ni qué métodos de pago se permiten — solo lee y renderiza.

El SDK se inicializa con una clave pública (pk_…). Las claves públicas están restringidas a alcances seguros para el cliente y es seguro incluirlas en el código del navegador. La sesión de checkout se crea en el servidor con una clave secreta (sk_…), que nunca debe aparecer en el navegador. Consulta Autenticación.

Cómo funciona

La sesión de checkout es la fuente de verdad. Tu servidor la crea y la modifica; el SDK se vincula a ella por id y lee su contexto para renderizar la interfaz.

Vincular una sesión de checkout

Pasa el checkoutSessionId creado en el backend al constructor del bridge. Después de que init() se resuelve, el bridge queda vinculado a ese checkout y puede leer su contexto.

import { TokeflowBridge } from '@tokeflow_com/bridge-js';

const tokeflow = new TokeflowBridge({
  publicKey: 'pk_live_mer_xxx',
  checkoutSessionId: 'cks_a1b2c3d4e5', // created by your backend
});

await tokeflow.init();

El checkoutSessionId lo crea tu servidor y se pasa al navegador — por ejemplo, incrustado en la página renderizada o solicitado por tu frontend desde tu propia API. No crees sesiones de checkout desde el código del cliente.

Leer el contexto

Llama a tokeflow.checkout.getContext() para obtener y almacenar en caché el contexto completo del checkout. Devuelve tres objetos de nivel superior: checkout (la sesión y sus ítems con precio), paymentMethods (lo que el Merchant puede aceptar) y savedInstruments (las tarjetas guardadas del cliente vinculado).

const context = await tokeflow.checkout.getContext();

console.log(context.checkout.selectedCurrency); // 'BRL'
console.log(context.paymentMethods.cards);      // true
console.log(context.savedInstruments.length);   // 0 or more

Ejemplo de contexto

{
  "checkout": {
    "id": "cks_a1b2c3d4e5",
    "merchantId": "mrc_a1b2c3d4e5",
    "offerId": "ofr_a1b2c3d4e5",
    "customerId": "cust_a1b2c3d4e5",
    "customerEmail": "jane@acme.com",
    "customerName": "Jane Doe",
    "selectedCurrency": "BRL",
    "status": "customer_identified",
    "externalSessionId": "sess_external_42",
    "expiresAt": "2026-05-20T18:00:00Z",
    "completedAt": null,
    "createdAt": "2026-05-19T12:00:00Z",
    "updatedAt": "2026-05-19T12:05:00Z",
    "items": [
      {
        "id": "cki_a1b2c3d4e5",
        "checkoutSessionId": "cks_a1b2c3d4e5",
        "offerId": "ofr_a1b2c3d4e5",
        "currency": "BRL",
        "amount": 9900,
        "firstChargeAmount": null,
        "quantity": 1,
        "installments": 1,
        "createdAt": "2026-05-19T12:00:00Z"
      }
    ]
  },
  "paymentMethods": {
    "cards": true,
    "pix": true,
    "boleto": false,
    "applePay": false,
    "googlePay": false,
    "cardBrands": ["visa", "mastercard"],
    "installmentsSupported": true,
    "installmentOptions": {
      "credit_card": { "min": 1, "max": 12 }
    }
  },
  "savedInstruments": [
    {
      "id": "pi_a1b2c3d4e5",
      "instrumentType": "card",
      "brand": "visa",
      "last4": "4242",
      "expMonth": 12,
      "expYear": 2030,
      "reusable": false
    }
  ],
  "savedCardCheckoutEnabled": false
}

checkout

La sesión de checkout que el SDK está renderizando. Los importes son instantáneas tomadas en el momento de la sesión, en unidades menores (centavos). El status sigue el ciclo de vida de la sesión de checkout.

FieldTypeDescription
idstringId de la sesión de checkout (cks_…).
merchantIdstringMerchant dueño de la sesión (mrc_…).
offerIdstringLa oferta que se está comprando (ofr_…).
customerIdstring | nullCliente vinculado (cust_…), o null hasta que se identifique.
customerEmailstring | nullCorreo del cliente, o null hasta que se identifique.
customerNamestring | nullNombre del cliente, o null hasta que se identifique.
selectedCurrencystring | nullMoneda ISO 4217 seleccionada para la sesión (p. ej. "BRL").
statusstringUno de initiated, customer_identified, payment_pending, completed, expired, abandoned.
externalSessionIdstring | nullTu propia referencia de sesión/cuenta, si está definida.
expiresAtstring | nullMarca de tiempo de expiración en ISO 8601.
completedAtstring | nullMarca de tiempo en ISO 8601 establecida cuando la sesión se completa.
createdAtstringMarca de tiempo de creación en ISO 8601.
updatedAtstringMarca de tiempo de última actualización en ISO 8601.
itemsarrayLos ítems de línea con precio (ver abajo).

Cada entrada en items:

FieldTypeDescription
idstringId del ítem de línea (cki_…).
checkoutSessionIdstringId de la sesión de checkout padre (cks_…).
offerIdstringLa oferta con precio (ofr_…).
currencystringCódigo de moneda ISO 4217.
amountintegerInstantánea del precio en unidades menores (p. ej. 9900 = R$99.00).
firstChargeAmountinteger | nullCuánto cobra el primer pago, en unidades menores, cuando eso difiere de amount; de lo contrario null. Lo establece un cargo de configuración, y también un periodo de prueba gratuito — que resuelve a 0, porque una prueba no cobra nada al inicio.
quantityintegerCantidad de esta línea.
installmentsintegerCuotas seleccionadas por el cliente (1 = cobro único).
createdAtstringMarca de tiempo de creación en ISO 8601.

paymentMethods

Los métodos de pago que el Merchant puede aceptar, resueltos a partir de su configuración de enrutamiento. Úsalos para renderizar solo las opciones que el Merchant realmente admite.

FieldTypeDescription
cardsbooleanSe aceptan pagos con tarjeta.
pixbooleanSe acepta PIX.
boletobooleanSe acepta boleto — true solo cuando un conector al que el merchant enruta el boleto puede cobrarlo.
applePaybooleanSe acepta Apple Pay.
googlePaybooleanSe acepta Google Pay.
cardBrandsstring[]Marcas de tarjeta aceptadas (p. ej. ["visa", "mastercard"]).
installmentsSupportedbooleanSi las cuotas están disponibles.
installmentOptionsobjectmin/max de cuotas indexados por método de pago (p. ej. { "credit_card": { "min": 1, "max": 12 } }).

savedInstruments

Las opciones de pago guardadas de un cliente que regresa — reducidas y seguras para el cliente. El arreglo está vacío cuando no hay ningún cliente vinculado o el cliente no tiene instrumentos guardados. Estas nunca incluyen identificadores sensibles; solo llevan lo que necesitas para renderizar una opción de "pagar con tarjeta guardada".

FieldTypeDescription
idstringId del instrumento de pago guardado (pi_…).
instrumentTypestringEl tipo de instrumento (p. ej. "card").
brandstring | nullMarca de la tarjeta (p. ej. "visa"), o null.
last4string | nullÚltimos cuatro dígitos, o null.
expMonthinteger | nullMes de expiración (1–12), o null.
expYearinteger | nullAño de expiración de cuatro dígitos, o null.
reusablebooleanIndicación orientativa (SDK 2.7.1+): true solo cuando el checkout con tarjeta guardada está habilitado para el merchant y este instrumento conserva una credencial almacenada en un conector activo capaz de cobrarlo en esta sesión. Los instrumentos que no son tarjeta siempre informan false.

savedCardCheckoutEnabled

boolean (SDK 2.7.1+). Si el checkout con tarjeta guardada está habilitado para el merchant — pagar una sesión de checkout con un instrumento guardado, sin volver a introducir la tarjeta. Refleja el opt-in saved_card_checkout_enabled del merchant tal como se aplica realmente, que está desactivado por defecto; mientras sea false, todo instrumento informa reusable: false. Trata ambos campos como false cuando falten.

Usa el Bridge SDK 2.7.1 o posterior. El paquete 2.7.0 publicado contenía el build de 2.6.0, por lo que sus bundles y tipos no incluyen savedCardCheckoutEnabled ni SavedInstrument.reusable.

Usa los dos campos para decidir qué tarjetas guardadas ofrecer:

const { savedInstruments, savedCardCheckoutEnabled } =
  await tokeflow.checkout.getContext();

const oneClickCards = savedCardCheckoutEnabled
  ? savedInstruments.filter((card) => card.reusable)
  : [];

El navegador nunca cobra un instrumento guardado — savedInstruments es de solo lectura y el SDK no tiene una llamada charge(). Cuando el cliente elige una tarjeta guardada, envía su id a tu servidor, que paga la sesión con POST /transactions y checkout_session_id, payment_instrument_id y credential_on_file: true. Consulta Checkout con tarjeta guardada. reusable es orientativo: el cargo aún puede rechazarse, así que mantén el formulario de tarjeta disponible como alternativa.

Métodos

El módulo Checkout está disponible en tokeflow.checkout después de init().

MethodReturnsDescription
getContext()Promise<CheckoutContext>Obtiene y almacena en caché el contexto del checkout. Se rechaza con NO_CHECKOUT_SESSION si no hay ninguna sesión vinculada.
getCachedContext()CheckoutContext | nullDevuelve el contexto en caché de forma síncrona (sin llamada de red); null si aún no se ha obtenido.
refresh()Promise<CheckoutContext>Vuelve a obtener el contexto después de que tu backend modifica el checkout (identifica al cliente, cambia ítems, etc.).
hasCheckoutSession()booleanSi hay una sesión de checkout vinculada a este bridge.

Lecturas en caché vs. lecturas frescas

getContext() almacena su resultado en caché. Recurre a getCachedContext() cuando necesites el contexto ya obtenido de forma síncrona — por ejemplo, durante un render — sin desencadenar una llamada de red.

// First read: network fetch + cache
const context = await tokeflow.checkout.getContext();

// Later, synchronously (no network):
const cached = tokeflow.checkout.getCachedContext();
if (cached) {
  renderSummary(cached.checkout.items);
}

Refrescar después de mutaciones del backend

El contexto del checkout es una instantánea. Cuando tu backend modifica la sesión — identifica al cliente, cambia ítems de línea o cambia la moneda — llama a refresh() para obtener el estado más reciente.

// e.g. after your server identifies the customer on the checkout
const updated = await tokeflow.checkout.refresh();
console.log(updated.checkout.customerEmail);   // now populated
console.log(updated.savedInstruments.length);  // saved cards now available

Identificar al cliente en el servidor y luego llamar a refresh() es la forma en que aparecen las tarjetas guardadas: savedInstruments se completa solo una vez que un cliente queda vinculado a la sesión.

Guardar la tarjeta con la que paga el cliente

Para que un cliente recurrente se salte la introducción de la tarjeta la próxima vez, tokeniza con saveCard: true cuando marque "guardar mi tarjeta". Para una oferta puntual eso emite un token registrable; una oferta recurrente siempre registra. Consulta Tokenización → Opciones.

const token = await tokeflow.cards.tokenize({ card: cardElement }, { saveCard: true });

Manejo de sesión no vinculada

Si el bridge se creó sin checkoutSessionId, las llamadas de checkout no tienen nada que leer. getContext() se rechaza con el código de error NO_CHECKOUT_SESSION; protégete con hasCheckoutSession() o captura el error.

import { TokeflowErrorCode } from '@tokeflow_com/bridge-js';

if (!tokeflow.checkout.hasCheckoutSession()) {
  // No checkout linked — fall back to a standalone tokenization flow.
}

try {
  const context = await tokeflow.checkout.getContext();
} catch (error) {
  if (error.code === TokeflowErrorCode.NO_CHECKOUT_SESSION) {
    // The bridge was initialized without `checkoutSessionId`.
  }
}

getContext() siempre refleja el estado del servidor. Trata los importes, la moneda y los métodos de pago disponibles como autoritativos — nunca dejes que el navegador anule lo que el servidor asignó como precio o habilitó.

React

Usa el hook useCheckout() para obtener, almacenar en caché y volver a renderizar el contexto del checkout. Requiere que checkoutSessionId esté definido en la configuración del TokeflowProvider.

import { TokeflowProvider, useCheckout } from '@tokeflow_com/bridge-js/react';

function App() {
  return (
    <TokeflowProvider
      config={{
        publicKey: 'pk_live_mer_xxx',
        checkoutSessionId: 'cks_a1b2c3d4e5', // from your backend
      }}
    >
      <CheckoutSummary />
    </TokeflowProvider>
  );
}

function CheckoutSummary() {
  const { context, isLoading, error, refresh } = useCheckout();

  if (error) return <p>{error.message}</p>;
  if (isLoading || !context) return <p>Loading…</p>;

  const { checkout, paymentMethods, savedInstruments } = context;

  return (
    <div>
      <ul>
        {checkout.items.map((item) => (
          <li key={item.id}>
            {item.offerId} — {item.amount} {item.currency} × {item.quantity}
          </li>
        ))}
      </ul>

      {paymentMethods.cards && <p>Card payments available</p>}
      {paymentMethods.pix && <p>PIX available</p>}

      {savedInstruments.length > 0 && (
        <ul>
          {savedInstruments.map((pi) => (
            <li key={pi.id}>
              {pi.brand} •••• {pi.last4} — {pi.expMonth}/{pi.expYear}
            </li>
          ))}
        </ul>
      )}

      <button onClick={() => refresh()}>Refresh</button>
    </div>
  );
}

El hook useCheckout() devuelve:

FieldTypeDescription
contextCheckoutContext | nullEl contexto obtenido, o null mientras carga o antes de la obtención.
isLoadingbooleanSi la obtención inicial está en curso.
errorTokeflowError | nullEl error de obtención, si lo hay (p. ej. NO_CHECKOUT_SESSION).
refresh() => Promise<CheckoutContext>Vuelve a obtener el contexto después de una mutación del backend.

Próximos pasos

En esta página