JS SDK Reference

Referencia completa de @allsign/embedded — inspirado en Plaid Link moderno y Typeform Embed. Modelo client_secret-only: una sola credencial pública, efímera, scoped a una session.

Instalación

npm install @allsign/embedded

O vía CDN para proyectos sin bundler:

<script src="https://js.allsign.io/v1/embed.js" async></script>

Inicialización

import { AllSign } from '@allsign/embedded';

const session = AllSign.init({
  clientSecret: 'as_sess_xxx_secret_yyy',
  // callbacks y opciones (ver tabla más abajo)
});

El clientSecret es la única credencial que el frontend maneja. Es efímero (15 min), single-use y scoped a una sola firma — lo genera tu backend con POST /v2/signing-sessions usando tu secret key, y lo pasas al frontend. Tu secret key nunca sale del backend.


Modos de embedding

Todas las funciones de montaje son métodos del objeto session devuelto por AllSign.init(). Las opciones visuales (locale, theme, values) se pasan en init; los métodos de montaje solo reciben el contenedor o config de posicionamiento.

session.modal()

Abre un overlay fullscreen sobre tu aplicación. El más fácil de integrar — no necesitas un contenedor.

const session = AllSign.init({
  clientSecret: 'as_sess_xxx_secret_yyy',
  locale: 'es-MX',
  theme: { primaryColor: '#1a73e8' },
  onSuccess: (result) => { /* firmado */ },
  onExit: (metadata) => { /* cerró */ },
  onEvent: (event) => { /* progreso */ },
});

session.modal();

session.inline(container)

Monta el widget dentro de un elemento DOM que tú controlas. Ideal cuando la firma es parte de tu layout.

const session = AllSign.init({
  clientSecret: 'as_sess_xxx_secret_yyy',
  locale: 'es-MX',
  values: { nombre: 'Juan', rfc: 'ABC123' },
  onSuccess: (result) => { /* firmado */ },
});

session.inline('#firma-container');
<div id="firma-container" style="width: 100%; height: 600px;"></div>

El widget comunica su altura al parent y se auto-redimensiona para evitar doble scroll.

session.slider(options)

Abre un panel lateral (drawer). El firmante firma sin perder contexto de lo que estaba haciendo en tu app.

const session = AllSign.init({
  clientSecret: 'as_sess_xxx_secret_yyy',
  onSuccess: (result) => { /* firmado */ },
});

session.slider({
  position: 'right',  // 'left' o 'right'
  width: 600,         // ancho en px (default: 500)
});

Opciones de AllSign.init()

Estas son todas las opciones que puedes pasar al crear la session:

ParámetroTipoRequeridoDefaultDescripción
clientSecretstringEl client_secret de tu Signing Session (creado en tu backend con POST /v2/signing-sessions)
locale'es-MX' | 'en-US''es-MX'Idioma de la interfaz
themeThemeOptionsPersonalización visual
valuesRecord<string, string>Pre-fill de variables del template desde el frontend
allowCancelbooleantruePermite al firmante cerrar/cancelar
onSuccess(result: SigningResult) => voidSe dispara cuando el firmante completó
onExit(metadata: ExitMetadata) => voidSe dispara cuando la sesión termina (por cualquier razón)
onEvent(event: SigningEvent) => voidSe dispara en cada paso del flujo (OTP, IDV, firma)
onReady() => voidSe dispara cuando el widget terminó de cargar

ThemeOptions

PropiedadTipoDescripción
primaryColorstringColor principal — botones, links, acentos (hex)
backgroundColorstringColor de fondo del widget
buttonTextstringTexto del botón principal (default: "Firmar documento")
logostringURL de tu logo (se muestra en el header)

El hook para React elimina todo el boilerplate. Inspirado en usePlaidLink.

npm install @allsign/embedded
import { useAllSignLink } from '@allsign/embedded/react';

function SignButton({ clientSecret }) {
  const { open, ready, error } = useAllSignLink({
    clientSecret,
    mode: 'modal',  // 'modal' | 'inline' | 'slider'

    onSuccess: (result) => {
      // result.signatureId — UUID de la firma
      // result.documentId  — UUID del documento
      // result.signedAt    — timestamp ISO-8601
      console.log('Firmado:', result.signatureId);
    },

    onExit: (metadata) => {
      // metadata.reason — 'completed' | 'cancelled' | 'expired' | 'error'
      // metadata.lastStep — último paso completado ('otp', 'id_scan', 'signature')
      console.log('Salió en:', metadata.lastStep);
    },

    onEvent: (event) => {
      // Eventos granulares para analytics y UI
      // event.name — 'OTP_SENT', 'OTP_VERIFIED', 'ID_SCAN_STARTED',
      //              'ID_SCAN_COMPLETED', 'DOCUMENT_VIEWED',
      //              'SIGNATURE_DRAWN', 'SIGNATURE_SUBMITTED'
      // event.timestamp — ISO-8601
      // event.metadata — datos adicionales del paso
      console.log('Evento:', event.name);
    },
  });

  if (error) return <p>Error: {error.message}</p>;

  return (
    <button onClick={open} disabled={!ready}>
      Firmar documento
    </button>
  );
}

Hook API

PropiedadTipoDescripción
open() => voidAbre la sesión de firma
readybooleantrue cuando el SDK cargó y el clientSecret es válido
errorError | nullError de inicialización (secret inválido, expirado, etc.)

Callbacks detallados

onSuccess(result)

Se dispara cuando el firmante completó su firma. Úsalo para feedback instantáneo en tu UI.

interface SigningResult {
  signatureId: string;    // UUID de la firma
  documentId: string;     // UUID del documento
  signerEmail: string;    // Email del firmante
  signedAt: string;       // Timestamp ISO-8601
}

onExit(metadata)

Se dispara siempre que la sesión termina, sin importar la razón. Es tu "catch-all" para cleanup.

interface ExitMetadata {
  reason: 'completed' | 'cancelled' | 'expired' | 'error';
  lastStep: 'otp' | 'id_scan' | 'variables' | 'document_view' | 'signature' | null;
  sessionId: string;
  documentId: string;
  error?: {
    code: string;
    message: string;
  };
}

lastStep te dice exactamente dónde abandonó el firmante — útil para analytics y para mostrar el paso correcto si vuelve a intentar.

onEvent(event)

Se dispara en cada paso del flujo. Granular, ideal para analytics y para mostrar progreso en tu UI.

interface SigningEvent {
  name: string;        // Nombre del evento
  timestamp: string;   // ISO-8601
  metadata: Record<string, any>;
}

Eventos disponibles:

EventoCuándo se dispara
SESSION_STARTEDEl widget se montó y cargó
OTP_SENTSe envió el código OTP (si está configurado)
OTP_VERIFIEDEl firmante verificó su OTP
ID_SCAN_STARTEDInició escaneo de identificación
ID_SCAN_COMPLETEDEscaneo de INE completado
SELFIE_CAPTUREDSelfie capturada para face match
BIOMETRIC_VERIFIEDFace match exitoso (INE vs selfie)
VARIABLES_FILLEDEl firmante completó las variables del formulario
DOCUMENT_VIEWEDEl firmante vio el documento
SIGNATURE_DRAWNEl firmante dibujó su firma
SIGNATURE_SUBMITTEDLa firma se envió al servidor
SESSION_COMPLETEDTodo el flujo terminó exitosamente

Métodos de instancia

session.close()

Cierra la sesión de firma y destruye el iFrame.

const session = AllSign.init({ clientSecret: '...' });
session.inline('#container');

// Después...
session.close();

session.unmount()

Desmonta el widget del DOM sin cerrar la sesión. Útil para cleanup en React.

useEffect(() => {
  const session = AllSign.init({ clientSecret });
  session.inline('#container');
  return () => session.unmount();
}, [clientSecret]);

HTML Data Attributes (no-code)

Para integraciones sin JavaScript (WordPress, Webflow, sitios estáticos):

<div
  data-allsign-session="as_sess_xxx_secret_yyy"
  data-allsign-mode="inline"
  data-allsign-locale="es-MX"
  data-allsign-theme-primary="#1a73e8"
  data-allsign-theme-button-text="Firmar contrato"
  style="width: 100%; height: 600px;">
</div>

<script src="https://js.allsign.io/v1/embed.js" async></script>

El script detecta los atributos data-allsign-* y monta automáticamente. Para escuchar eventos, usa custom events del DOM:

document.addEventListener('allsign:success', (e) => {
  console.log('Firmado:', e.detail.signatureId);
});

document.addEventListener('allsign:exit', (e) => {
  console.log('Razón:', e.detail.reason);
});

TypeScript

El SDK incluye tipos completos:

import type {
  AllSignSession,
  AllSignInitOptions,
  SigningResult,
  ExitMetadata,
  SigningEvent,
  ThemeOptions,
} from '@allsign/embedded';

import type {
  UseAllSignLinkOptions,
  UseAllSignLinkReturn,
} from '@allsign/embedded/react';

Manejo de errores

const session = AllSign.init({
  clientSecret: '...',
  onExit: (metadata) => {
    if (metadata.reason === 'error') {
      switch (metadata.error?.code) {
        case 'SESSION_EXPIRED':
          // El client_secret expiró — genera uno nuevo en tu backend
          refreshSession();
          break;
        case 'SESSION_INVALID':
          // Token inválido o ya consumido
          showError('Esta sesión de firma ya no es válida.');
          break;
        case 'NETWORK_ERROR':
          // Error de red
          showError('Error de conexión. Intenta de nuevo.');
          break;
        case 'DOCUMENT_NOT_FOUND':
          showError('El documento ya no está disponible.');
          break;
        case 'DOCUMENT_COMPLETED':
          showInfo('Este documento ya fue firmado.');
          break;
        case 'DOCUMENT_CANCELLED':
          showError('Este documento fue anulado.');
          break;
      }
    }
  },
});

Códigos de error

CódigoDescripción
SESSION_EXPIREDEl client_secret expiró (>15 min). Genera uno nuevo.
SESSION_INVALIDToken inválido o ya consumido.
NETWORK_ERRORNo se pudo cargar el widget (red, CORS, CSP).
DOCUMENT_NOT_FOUNDEl documento no existe o fue eliminado.
DOCUMENT_COMPLETEDEl documento ya fue firmado por todos.
DOCUMENT_CANCELLEDEl documento fue anulado por el creador.
SIGNER_NOT_FOUNDEl firmante no está asociado al documento.
CAMERA_DENIEDEl usuario no permitió acceso a la cámara (necesario para IDV).

Compatibilidad

BrowserVersión mínima
Chrome80+
Firefox78+
Safari14+
Edge80+
Mobile Safari (iOS)14+
Chrome Android80+

Siguiente paso

Was this page helpful?