Conecte Moodle con CertLister

Tiempo de lectura: 10 minutos

Plan requerido: Pro (las rutas A y B usan integraciones de API y webhooks) · Cualquier plan para la ruta C

Moodle es uno de los sistemas de gestión de aprendizaje más usados — y una de las preguntas más comunes que recibimos es: "¿CertLister puede emitir una credencial automáticamente cuando un estudiante completa un curso de Moodle?"

Sí. Moodle no envía webhooks de fábrica, pero hay tres formas confiables de conectarlo con CertLister. Esta guía recorre las tres, de la totalmente automática a la totalmente manual.

¿Qué ruta debo usar?

Nuestra recomendación: si opera su propio Moodle (o su proveedor de alojamiento puede instalar plugins), use la Ruta A — es en tiempo real, no requiere código y toma unos 20 minutos configurar. Si está en MoodleCloud o no puede instalar plugins, use la Ruta B si cuenta con un desarrollador, o la Ruta C si no.

Ruta A — plugin Event Trigger + webhook entrante (recomendada)

En esta configuración, el plugin Event Trigger gratuito (tool_trigger, mantenido por Catalyst IT) vigila el evento de Curso completado en Moodle y envía un HTTP POST a un webhook entrante de CertLister. CertLister crea la credencial — y puede enviarla por correo al estudiante — en el momento en que completa el curso.

Curso de Moodle completado → flujo de Event Trigger → HTTP POST → webhook de CertLister → Credencial emitida → Correo enviado

Paso 1 — cree el webhook entrante en CertLister

1. En CertLister, vaya a Integraciones → pestaña Webhooks
2. Haga clic en Crear webhook
3. Complete:
   • Nombre — p. ej., "Finalizaciones de cursos de Moodle"
   • Modo — Crear (crea automáticamente una credencial a partir de los datos entrantes)
   • Categoría — la categoría a la que irán las credenciales nuevas
   • Diseño — opcionalmente elija un diseño guardado para que las credenciales usen su plantilla
   • Enviar correo — actívelo para enviar automáticamente su credencial a cada estudiante
4. Configure los mapeos de campos — asocie los campos JSON que Moodle enviará con los campos de la credencial:

(Coinciden con el cuerpo JSON que construirá en Moodle en el Paso 3. Puede agregar más mapeos para atributos personalizados — vea Agregar más datos más abajo.)

5. Haga clic en Crear y copie la URL del webhook. Se ve así:

https://app.certlister.com/api/v1/hooks/su-token-de-endpoint

Mantenga esta URL en secreto. El token del punto de acceso en la URL es lo que autoriza las solicitudes. Cualquiera con la URL puede crear credenciales en su cuenta — trátela como una contraseña, y regenérela desde la tarjeta del punto de acceso si alguna vez se filtra.

Paso 2 — instale el plugin Event Trigger en Moodle

1. En Moodle, vaya a Administración del sitio → Extensiones → Instalar complementos
2. Busque Event Trigger (tool_trigger) en el directorio de plugins, o suba el ZIP desde la página del plugin
3. Complete los pasos de instalación y actualización

Nota: instalar plugins requiere acceso de administrador del sitio y no es posible en MoodleCloud. Si es su caso, pase a la Ruta B o la Ruta C.

Paso 3 — cree el flujo de trabajo en Moodle

1. Vaya a Administración del sitio → Servidor → Event Trigger
2. Haga clic en Agregar flujo de trabajo y complete:
   • Nombre — p. ej., "Enviar finalizaciones a CertLister"
   • Evento — busque y seleccione Curso completado (\core\event\course_completed)
   • Activo — déjelo apagado por ahora; lo habilitará después de probar
3. Agregue los pasos del flujo, en este orden:

Paso 3a — búsqueda de usuario. El evento crudo solo contiene el userid numérico del estudiante. Agregue un paso de User lookup (leyendo el campo relateduserid — en las finalizaciones de curso, ese es el estudiante) para que el flujo gane campos como {user_fullname} y {user_email}.

Paso 3b — búsqueda de curso. Lo mismo para el curso: agregue un paso de Course lookup leyendo el campo courseid, que agrega {course_fullname} y {course_shortname}.

Paso 3c — acción HTTP POST. Agregue un paso de acción HTTP POST:

• URL — la URL de su webhook de CertLister del Paso 1
• Encabezados HTTP:

Content-Type: application/json

• Parámetros HTTP (cuerpo):

{
  "recipient_name": "{user_fullname}",
  "recipient_email": "{user_email}",
  "title": "{course_fullname}"
}

Los {marcadores} se reemplazan con los valores reales de los pasos de búsqueda cuando el flujo se dispara.

4. Guarde el flujo de trabajo.

Consejo — modo aprendizaje: si no está seguro de qué campos de datos hay disponibles, habilite el Learning mode del flujo, complete un curso de prueba una vez, y Event Trigger registrará el evento y le mostrará cada campo que puede usar como marcador.

Paso 4 — pruebe de extremo a extremo

1. En Moodle, inscriba un usuario de prueba en un curso con criterios de finalización configurados (Curso → configuración de Finalización del curso — la finalización debe estar habilitada, o el evento nunca se dispara)
2. Complete el curso como el usuario de prueba (o márquelo completo manualmente como profesor)
3. Moodle dispara el evento en uno o dos minutos (los flujos corren con el cron de Moodle — asegúrese de que el cron esté funcionando)
4. En CertLister, vaya a Integraciones → Webhooks y abra los Registros del punto de acceso — debería ver la solicitud, su carga y el resultado
5. Revise su página de Credenciales: la credencial nueva debería estar ahí, y si Enviar correo está activo, el estudiante la habrá recibido

Cuando la prueba pase, ponga el flujo de Moodle en Activo. Cada finalización de curso emite ahora una credencial automáticamente.

Agregar más datos desde Moodle

¿Quiere el nombre corto del curso, metadatos de finalización u otros campos en la credencial? Agréguelos al cuerpo JSON en Moodle:

{
  "recipient_name": "{user_fullname}",
  "recipient_email": "{user_email}",
  "title": "{course_fullname}",
  "course_code": "{course_shortname}"
}

Luego mapee course_code a un atributo personalizado en los mapeos de campos de CertLister. Los atributos personalizados pueden imprimirse en el diseño de la credencial y mostrarse en la página de verificación — consulte Atributos de credencial personalizados.

Puede dejar issue_date sin mapear — CertLister sella la credencial con la fecha de creación, que para un webhook en tiempo real es la fecha de finalización.

Un curso, un tipo de credencial

Un punto de acceso de webhook tiene una categoría y un diseño. Si distintos cursos de Moodle deben emitir credenciales distintas:

1. Cree un punto de acceso de webhook de CertLister por curso (o por tipo de credencial), cada uno con su categoría y diseño
2. En Moodle, cree un flujo de trabajo por curso, agregando un paso de Filter sobre courseid para que cada flujo solo se dispare para su curso, y apunte cada uno a la URL de webhook correspondiente

Para un puñado de cursos esto es rápido; para catálogos grandes, considere la Ruta B, donde un script puede enrutar dinámicamente.

Ruta B — script de sondeo mediante los servicios web de Moodle

Si no puede instalar plugins de Moodle (p. ej., MoodleCloud), un script pequeño puede sondear la API de servicios web integrada de Moodle en busca de finalizaciones y crear credenciales a través de la API REST de CertLister. Es casi en tiempo real — tan fresco como su intervalo de sondeo.

Cron/planificador → Servicios web de Moodle (finalizaciones) → API REST de CertLister → Credencial emitida

Paso 1 — habilite los servicios web en Moodle

En Moodle, como administrador del sitio:

1. Administración del sitio → General → Características avanzadas → habilite Servicios web
2. Administración del sitio → Servidor → Servicios web → Gestionar protocolos → habilite REST
3. Servicios web → Servicios externos → agregue un servicio personalizado y añádale estas funciones:
   • core_enrol_get_enrolled_users — listar los estudiantes de un curso
   • core_completion_get_course_completion_status — consultar la finalización de un estudiante
4. Cree un usuario de Moodle dedicado a la integración, dele un rol con solo las capacidades que esas funciones requieren y autorícelo para su servicio
5. Servicios web → Gestionar tokens → cree un token para ese usuario

La propia documentación de servicios web de Moodle cubre cada pantalla en detalle.

Paso 2 — cree una clave de API de CertLister

1. En CertLister, vaya a Integraciones → pestaña Claves de API
2. Haga clic en Crear clave de API, nómbrela (p. ej., "Sincronización Moodle") y dele los alcances credentials:read y credentials:write
3. Copie la clave (cl_live_...) — se muestra una sola vez

Paso 3 — ejecute un script de sondeo

El script de abajo revisa un curso de Moodle en busca de finalizaciones y emite una credencial a quien lo haya completado y aún no tenga una. Ejecútelo con un planificador (cron, GitHub Actions, Cloud Scheduler — cada 15 minutos funciona bien).

// moodle-sync.js — Node.js 18+
const MOODLE_URL = "https://su-sitio-moodle.example.com";
const MOODLE_TOKEN = "su-token-ws-de-moodle";
const COURSE_ID = 42; // id del curso en Moodle
const COURSE_NAME = "Capacitación en seguridad laboral";
const CERTLISTER_KEY = "cl_live_su_clave_de_api";
const CERTLISTER_API = "https://app.certlister.com/api/v1/external";

async function moodle(wsfunction, params) {
  const query = new URLSearchParams({
    wstoken: MOODLE_TOKEN,
    wsfunction,
    moodlewsrestformat: "json",
    ...params,
  });
  const res = await fetch(`${MOODLE_URL}/webservice/rest/server.php?${query}`);
  return res.json();
}

async function certlister(path, options = {}) {
  const res = await fetch(`${CERTLISTER_API}${path}`, {
    ...options,
    headers: {
      Authorization: `Bearer ${CERTLISTER_KEY}`,
      "Content-Type": "application/json",
      ...options.headers,
    },
  });
  return res.json();
}

async function main() {
  const users = await moodle("core_enrol_get_enrolled_users", {
    courseid: COURSE_ID,
  });

  for (const user of users) {
    const status = await moodle("core_completion_get_course_completion_status", {
      courseid: COURSE_ID,
      userid: user.id,
    });
    if (!status.completionstatus?.completed) continue;

    // Omitir estudiantes que ya tienen esta credencial
    const existing = await certlister(
      `/credentials?search=${encodeURIComponent(user.email)}`
    );
    const alreadyIssued = (existing.data || []).some(
      (c) => c.title === COURSE_NAME && c.recipient_email === user.email
    );
    if (alreadyIssued) continue;

    await certlister("/credentials", {
      method: "POST",
      body: JSON.stringify({
        recipient_name: user.fullname,
        recipient_email: user.email,
        title: COURSE_NAME,
        send_email: true,
      }),
    });
    console.log(`Credencial emitida a ${user.fullname}`);
  }
}

main();

Adáptelo según necesite: recorra varios cursos, establezca category_id y design_id por curso (lístelos con GET /external/categories y GET /external/designs), o agregue custom_attributes. La referencia completa de los puntos de acceso está en Integraciones de API y webhooks.

Ruta C — exportación CSV + importación masiva

Sin plugins, sin código, funciona en todas partes — incluido MoodleCloud. Ideal para emitir credenciales al final de una sesión de curso en lugar de continuamente.

1. En Moodle, abra el curso y vaya al reporte de finalización del curso (Reportes → Finalización del curso) — o al libro de calificaciones — y descargue el reporte como CSV
2. En una hoja de cálculo, conserve las columnas que necesita: nombre del estudiante, correo y fecha de finalización
3. En CertLister, vaya a Credenciales → Importar y cargue el CSV, mapeando las columnas a los campos de la credencial
4. Revise y confirme — CertLister crea las credenciales y puede enviarlas por correo en masa

Recorrido completo: importación masiva de credenciales.

Bueno saberlo

Límites de solicitudes. Los webhooks entrantes aceptan 30 solicitudes por minuto por punto de acceso, y la API REST permite 100 solicitudes por minuto por clave. Las finalizaciones normales de curso nunca se acercan a esto — pero si marca como completa a una cohorte grande de golpe en Moodle, Event Trigger puede disparar cientos de webhooks en ráfaga y algunos serán rechazados con 429. Para operaciones por lotes grandes, prefiera la Ruta B (el script se autorregula) o la Ruta C.

Protección contra duplicados. El modo de creación del webhook crea una credencial por cada solicitud recibida. Moodle solo dispara Curso completado una vez por estudiante por curso, así que los duplicados son raros en la práctica — pero si vuelve a ejecutar finalizaciones (p. ej., reiniciando y recompletando un curso), revise los Registros del webhook y su lista de Credenciales.

La finalización debe estar configurada. El evento Curso completado solo se dispara en cursos con criterios de finalización habilitados en Moodle (Curso → configuración de Finalización del curso). Si los webhooks nunca llegan, esto es lo primero que revisar — luego confirme que el cron de Moodle esté funcionando, ya que los flujos de Event Trigger corren con el cron.

Verificación de credenciales. Cada credencial emitida desde Moodle recibe la misma página de verificación, código QR y acceso al portal de destinatarios que cualquier otra credencial de CertLister — consulte Portal de destinatarios.

Solución de problemas

Artículos relacionados

• Integraciones de API y webhooks — referencia completa de la API REST y los webhooks
• Automatizaciones de flujo de trabajo — active correos y acciones cuando se emiten credenciales
• Importación masiva de credenciales — el flujo de importación CSV usado en la Ruta C
• Atributos de credencial personalizados — imprima los datos del curso de Moodle en sus credenciales