17 mars 2026 · 24 min read

XAPI dans les détails

XAPI est un standard ouvert qui permet de tracer les interactions avec un système

#xapi #Learning Analytics #LRS #Traces d'apprentissage

XAPI c’est quoi?

AdlNet développe le standard XAPI afin de combler les limites de SCORM. XAPI permet un suivi précis de l’apprentissage avec des traces complètes au format JSON dans lequel on trouve l’acteur, un verbe, la ressource et le résultat. Pour mieux comprendre ce standard, ADLNet met à disposition Xapilab permettant de construire une trace directement en ligne pour XAPI V1. XAPI fonctionne avec un Learning Record Store (LRS), il s’agit d’une base de données noSQL souvent accessible en HTTP directement. Il existe différents LRS comme TRAX LRS qui est open source (code sur GITHUB), il existe également une version payante offrant plus de fonctionnalités. Il existe également le LRS de Rustici Software qui permet d’être installé directement dans votre SI et une version cloud sur cloud avec Scorm cloud. L’avantage d’voir un LRS c’est la simplicité et l’interopérabilité, on produit un json au format XAPI sur un LRS en HTTP (ou via des SDK) et on récupère ce JSON en HTTP également par n’importe quel outil d’analyse, un LMS mais aussi pourquoi pas powwerBi tout autre outil capable de traiter des requêtes HTTP et de lire du JSON.

Histoire

Le standard xAPI a été créé par l’ADL en 2010. La définition de ce standard fait suite à une réflexion collective engagée par la fédération Learning-Education-Training Systems Interoperability (LETSI) permettant d’identifier les limites du modèle SCORM ainsi que les exigences d’une nouvelle génération de standard pour l’e-learning.

L’objectif de ce nouveau standard consiste à ne plus se limiter au suivi de l’achèvement de cours, aux scores ou au nombre de pages consultées, mais de permettre la collecte de toute activité d’apprentissage, y compris en dehors des LMS, sur des dispositifs et des contextes variés. Les données produites doivent pouvoir être analysées et mises en relation avec des indicateurs de performance et de productivité.

En 2011, l’ADL confie à Rustici Software un contrat de recherche visant à proposer une approche technologique de référence. Ce projet, baptisé Project Tin Can servira de base à la future Experience API.

Un groupe de travail piloté par l’ADL est ensuite constitué afin de faire mûrir ces propositions, aboutissant à la publication de la première version officielle de xAPI (version 1.0) en 2013. Depuis, le standard a connu une adoption croissante au sein de l’écosystème e-learning, notamment dans des contextes institutionnels, industriels et gouvernementaux.

À partir de 2020, la spécification xAPI entre dans un processus de normalisation formelle auprès de l’IEEE. Cette standardisation vise à renforcer l’adoption internationale de xAPI et à stabiliser ses usages. (Sources Adlnet.gov).

La spécification de la version 2.0 ici

Les pré requis

IRI

XAPI identifie des ressources à l’aide d’IRI (Internationel resources Identifiers) définit par le RFC3987. L’idée est de définir une ressource de manière unique, c’est la suite des URI RFC3986.

Le concept important est celui de ressources. Il s’agit d’une notion regroupant tout élément pouvant être identifié. Un document numérique, un être humain, des entreprises , des objets abstrait, des nombres, des chiffres etc…

L’identifiant c’est ce qui va permettre d’identifier une ressource d’une autre. Le but n’est pas d’accéder à la ressource mais de l’identifier seulement. Une IRI peut parfaitement pointer sur rien. C’est un peu comme un numéro de sécurité sociale il permet d’identifier un citoyen Français mais pas forcément d’aller sonner à sa porte. La différence c’est qu’une IRI peut aussi pointer sur la ressource elle-même.

La notion d’international c’est que dans une IRI on peut mettre des caractères UTF-8.

Language Map

Les noms des ressources sont définis dans xAPI selon le format Language Map. Il s’agit d’un objet JSON dont les clés sont des balises de langue conformes au RFC5646 et les valeurs sont les chaînes de texte dans la langue correspondante.

Voici un exemple de Language Map

{
	"en-US":"simple CBT course",
    "fr-FR": "Simple cours CBT"
}

L’idée pour XAPI est de mettre dans le même endroit sous un même identifiant les traductions des noms de ressources. En respectant ce format XAPI offre une seule trace même s’il y a plusieurs traductions. De plus, n’importe quel système peut comprendre la ressource dans sa langue.

Modèle de données

XAPI se rapproche du langage naturel pour exprimer un évènement à savoir quelqu’un a fait quelque chose sur quelque chose.

Par exemple : Julie a terminé le devoir de mathématique

Ce standard propose des statements qui représentent ces phrases construites autour des propriétés suivantes :

RessourcesDescriptionLien
ActeurUne personne ou un groupe responsable de l’actionici
VerbeDéfinit une action, plus de détailsici
objetC’est l’objet sur lequel porte l’actionici
resultle résultats obtenuici

Concrètement, il s’agit d’une trace au format JSON dont voici un exemple plus de détails ici:

{
	"id":"7ccd3322-e1a5-411a-a67d-6a735c76f119",
	"timestamp": "2015-12-18T12:17:00+00:00",
	"actor":{
        "objectType": "Agent",
		"name":"Example Learner",
		"mbox":"mailto:example.learner@adlnet.gov"
	},
	"verb":{
		"id":"http://adlnet.gov/expapi/verbs/attempted",
		"display":{
			"en-US":"attempted"
		}
	},
	"object":{
		"id":"http://example.adlnet.gov/xapi/example/simpleCBT",
		"definition":{
			"name":{
				"en-US":"simple CBT course"
			},
			"description":{
				"en-US":"A fictitious example CBT course."
			}
		}
	},
	"result":{
		"score":{
			"scaled":0.95
		},
		"success":true,
		"completion":true,
		"duration": "PT1234S"
	}
}

Acteur

Pour identifier un acteur de manière unique, xAPI utilise ce qu’on appelle un IFI (Inverse Functional Identifier) — une valeur qui garantit de ne référer qu’à un seul et unique acteur. Il en existe quatre : mbox, mbox_sha1sum, openid et account. Un seul IFI à la fois doit être présent.

account est l’IFI le plus courant dans les contextes métier. Il se compose de deux propriétés :

C’est la combinaison des deux qui forme un identifiant unique :

"actor": {
  "objectType": "Agent",
  "name": "Adrien Dupont",
  "account": {
    "homePage": "https://centreFormationA.fr",
    "name": "ELV-004271"
  }
}

homePage indique le système auquel appartient l’identifiant ELV-004271 — ici le centre de formation A. C’est ce qui permet d’éviter les collisions : l’identifiant ELV-004271 chez le centre A n’est pas le même que chez un autre organisme. Si Adrien existe dans d’autres systèmes avec un identifiant différent, ce cas devra être géré en dehors de xAPI, par exemple via un référentiel d’identités ou le standard OneRoster.

Vous trouverez plus de détails sur les acteurs dans xAPI ainsi que des informations sur la représentations des groupes ici

Verbe

Le verbe va définir le type de la trace. Si la trace représente la fin d’un exercice alors le verbe pourrait être completed par exemple. S’il s’agit d’une trace représentant une interaction alors le verbe pourrait être interacted. Un verbe est définit par un identifiant id au format IRI et une propriété Display au formal Language Map. L’id est le seul élément requis mais c’est recommandé d’ajouter display afin d’avoir la représentation du verbe dans plusieurs langages.

Initialement, les verbes étaient pré-définis par AdlNet mais ils ont été retiré sur standard pour permettre plus de flexibilité. N’importe quelle IRI peut servir de verbe. Toutefois, un registre de verbe est maintenu mais plus a des fins d’interopérabilités Registre de verbes. Aucun verbe n’est imposé par XAPI.

Il y a cependant un verbe réservé qui concerne l’annulation d’une trace. Il s’agit du verbe voided avec lIRI suivant : http://adlnet.gov/expapi/verbs/voided

Pour plus d’information sur les acteurs en XAPI ainsi que sur la représentation d’un group je vous suggère ce site Xapi.com.

Voici un exemple de verbe représentant une des tentative pour un exercice :

"verb":{
		"id":"http://adlnet.gov/expapi/verbs/attempted",
		"display":{
		"en-US":"attempted"
	}
}

Object

Un objet est l’élément central d’xAPI, il peut être de plusieurs types :

Activity : Une activité représente ce avec quoi un utilisateur interagit

Un objet représente une activité
Un objet représente une activité

Pour définir un objet il faut définir les propriétés suivantes :

Ce ne sont que des exemples, vous êtes libre de choisir une autre forme, tant qu’il s’agit d’une IRI et que l’activité est identifiée de manière unique.

Une activité en XAPI peut-être de plusieurs types d’interactions, héritage direct de scorm; comme des QCM, des échelles de Likert, des activité de types “à compléter”, ou des actvités ou des réponses longues sont attendues comme une dissertation par exemple ou encore d’autres types d’interaction. Un objet de type Activity ne doit pas forcément définir quel type d’interaction il s’agit mais c’est quand même plus précis.

{
  "actor": {
    "objectType": "Agent",
    "name": "Marie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/answered",
    "display": { "fr": "a répondu" }
  },
  "object": {
    "id": "https://centreFormationA.fr/questions/securite-001",
    "definition": {
      "description": { "fr": "Le port du casque est obligatoire sur un chantier?" },
      "type": "http://adlnet.gov/expapi/activities/cmi.interaction",
      "interactionType": "true-false",
      "correctResponsesPattern": [ "true" ]
    }
  }
}

Ce statement signifie que Marie Dupont élève du centre de formation A, a répondu à une question Le port du casque est obligatoire sur un chantier, la réponse vrai est attendue, Vous trouverez des exemples de traces XAPI pour chaque type d’interaction

Pour les autres types d’interaction (vrai/faux, texte libre, Likert…), vous trouverez des exemples complets dans la spec annexe C.

Agent/group : Représente un individu ou un groupe

Un objet peut également représenter un individu ou un groupe

Un objet représente un acteur
Un objet représente un acteur

Dans ce cas, l’objet a le format de l’acteur ou du groupe.

{
  "actor": {
    "objectType": "Agent",
    "name": "Paul Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/scored",
    "display": {
      "fr": "a evalué "
    }
  },
  "object": {
    "objectType": "Agent",
    "name": "Marc Martin",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "FORM-001"
    }
  }
}

On peut également avoir un groupe si un individu fait une action sur un groupe par exemple :

Un objet représente un groupe
Un objet représente un groupe

Un groupe contient également les membres donc on peut voir les membres du jury qui ont évalué le groupe 1 ainsi que les membres du groupe1.

SubStatement et Statementref : L’objet est une trace ou une référence à une trace

Un SubStatement est un statement imbriqué dans un autre statement. C’est à dire que “quelqu’un a fait quelque chose… à propos d’une autre action”

{
  "actor": {
    "name": "Formateur",
    "mbox": "mailto:formateur@example.com"
  },
  "verb": {
    "id": "http://example.com/verbs/validated",
    "display": { "fr": "a validé" }
  },
  "object": {
    "objectType": "SubStatement",
    "actor": {
      "name": "Marie",
      "mbox": "mailto:marie@example.com"
    },
    "verb": {
      "id": "http://adlnet.gov/expapi/verbs/answered",
      "display": { "fr": "a répondu" }
    },
    "object": {
      "id": "http://example.com/question/1",
      "definition": {
        "name": { "fr": "Question de sécurité" }
      }
    }
  }
}

L’objet devient un statement complet avec un acteur, un verbe, un objet etc.

Une trace contient un identifiant unique, si un objet est de type StatementRef, alors il faut simplement référencer cet identifiant en tant qu’identifiant de l’objet.

Prenons l’exemple suivant Julie à commenté la trace fa79dcf6-c2ae-4024-a703-913eea57a592

 ```json
{
  "actor": {
    "objectType": "Agent",
    "name": "Julie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-00765"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/scored",
    "display": {
      "fr": "a evalué "
    }
  },
  "object": {
    "id": "fa79dcf6-c2ae-4024-a703-913eea57a592",
    "objectType": "StatementRef"
    }
  }

Un objet est un élément central dans xAPI. En effet, il permet de donner le sens de la trace ce sur quoi elle porte. On peut savoir qu’une action a été réalisé par un individu ou un groupe d’individu sur une activité sur laquelle on peut définir le type d’interaction, sur un individu ou un groupe d’individus, sur une autre trace ou encore l’objet peut représenter une trace complète. c’est l’attribut objectType qui permet de donner le type d’objet (actor, group, activity etc…).

A présent que l’on sait qui a fait quoi, on va ajouter dans la section suivante le résultat de cette action.

Result

Pour exprimer le résultat de l’action (Verbe) sur l’objet, XAPI offre plusieurs propriétés toutes optionnelles à choisir en fonction du besoin.

On peut donc compléter une trace ou un statement en ajoutant le résultat. Prenons l’exemple suivant :

Marie a répondu vrai à la question “Le port du casque est obligatoire sur un chantier?”, la réponse attendue est vrai. En XAPI cela donne :

{
  "actor": {
    "objectType": "Agent",
    "name": "Marie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/answered",
    "display": { "fr": "a répondu" }
  },
  "object": {
    "id": "https://centreFormationA.fr/questions/securite-001",
    "definition": {
      "description": { "fr": "Le port du casque est obligatoire sur un chantier?" },
      "type": "http://adlnet.gov/expapi/activities/cmi.interaction",
      "interactionType": "true-false",
      "correctResponsesPattern": [ "true" ]
    }
  },
  "result":{
    "response": "true",
    "success": true
  }
}

Remarquez que Response est une chaîne de caractère.

Context

Il s’agit d’un élément central également dans XAPI. Cela permet d’éviter l’isolement d’une trace c’est à dire une trace decontextualisée dont on arrive pas à rattacher à quoi que ce soit. Il y a bien sûr déjà pas mal de contexte avec le type d’interaction d’une activité, le résultat obtenu, attendu, la logique de notation avec le score minimum et maximum même si c’est pas suffisant pour décrire une logique complète de notation comme le propose CMI5 par exemple. Cependant, malgré le contexte déjà présent comment savoir que l’activité appartient au cours “Sécurité chantier” par exemple ? Une trace peut appartenir à un groupe ou une catégorie, elle peut être inscrite dans une session. Tout ceci s’expriment dans le contexte du statement.

Corréler des traces registration

Dans le contexte l’attribut registration permet de décrire une session par exemple. En fait cela permet d’inscrire la trace dans une tentative ou une session. En effet, lors d’une session plusieurs traces peuvent être émises. Prenons l’exemple suivant dans la session d’exercice du 8 janvier 2025 les étudiants Julie, Marc, Marie et Paul ont :

Un groupe de jury a noté chaque étudiant

Si toutes ces traces ont la même valeur de registration elles sont corrélées entre elles. C’est le système émetteur (le LMS par exemple) qui est responsable de générer ce UUID et de conserver la correspondance avec le nom humain de la session, xAPI ne le gère pas nativement.

xAPI peut produire un nombre conséquent de traces. Dans un groupe de 30 étudiants si on souhaite conserver des traces du début d’exercices, une trace par question, etc.. le nombre de traces augmente rapidement, l’attribut registration donne un identifiant de correlation qui peut servir de filtre pour obtenir les traces seulement d’une session d’examen ou d’une tentative d’une exercice si les étudiants sont autorisés à faire plusieurs fois un exercice et que cet exercice comporte plusieurs traces, registration sert alors de discriminant afin de récupérer les traces d’une tentative seulement.

Le contexte d’une activité ActivityContext

L’attribut ActivityContext est un objet qui contient plusieurs propriétés permettant de donner plus d’informations sur la trace comme son parent (un module de formation, un cours, un chapitre etc..), si elle appartient à un groupe (algèbre, Expression Ecrite etc…), ainsi que la catégorie de la trace si c’est pertinent. Il existe quatre types de relation :

Reprenons notre exemple : Marie répond à une question de l’exercice 3445, qui appartient au chapitre Sécurité chantier :

"contextActivities": {
  "parent": [{
    "id": "https://centreFormationA.fr/exercices/3445",
    "definition": { "name": { "fr": "Exercice 3445" } }
  }],
  "grouping": [{
    "id": "https://centreFormationA.fr/modules/securite-chantier",
    "definition": { "name": { "fr": "Module Sécurité chantier" } }
  }]
}

Pour un exemple plus complet prenons le cours sur la sécurité chantier qui contient un chapitre sur les équipements. Le 19 mars 2025, il y a une session d’examen sur ce chapitre Les équipements de sécurité chantier. La hiérarchie est la suivante :

Un objet représente une activité
Un objet représente une activité

L’objet de la trace est de type Activity. Dans cet exemple, supposons que le type d’interaction soit true/false. Il y a une trace ou statement par question donc ici 3 statements Q1, Q2 et Q3. L’attribut registration relie ces traces entre elles car elles appartiennent toutes à la session d’examen du 19 mars 2025. L’objectif ici est de pouvoir fournir le contexte structurel de la trace c’est à dire que la question Q1 appartient à l’activité 3445, c’est directement donné dans l’objet du statement. Cette activité appartient au chapitre équipement c’est ici qu’intervient le contexte et notamment l’attribut parent. Enfin on souhaite également exprimer que ce chapitre appartient au cours sur la sécurité chantier cela est rendu possible par l’attribut group. Voici un exemple d’une trace XAPI complète représentant l’évaluation de Q1 avec la structure donnée dans la trace.

{
  "id": "7ccd3322-e1a5-411a-a67d-6a735c76f119",
  "timestamp": "2025-03-19T09:14:00+00:00",
  "actor": {
    "objectType": "Agent",
    "name": "Marie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/answered",
    "display": { "fr": "a répondu" }
  },
  "object": {
    "objectType": "Activity",
    "id": "https://centreFormationA.fr/exercice-3445/question-1",
    "definition": {
      "name": { "fr": "Question 1" },
      "description": { "fr": "Le port du casque est obligatoire sur un chantier." },
      "type": "http://adlnet.gov/expapi/activities/cmi.interaction",
      "interactionType": "true-false",
      "correctResponsesPattern": [ "true" ]
    }
  },
  "result": {
    "response": "true",
    "success": true,
    "completion": true,
    "duration": "PT42S"
  },
  "context": {
    "registration": "a3f2b1c0-19d3-4e8a-b567-2025031900ex",
    "contextActivities": {
      "parent": [{
        "id": "https://centreFormationA.fr/chapitres/equipements",
        "definition": { "name": { "fr": "Chapitre — Équipements" } }
      }],
      "grouping": [{
        "id": "https://centreFormationA.fr/cours/securite-chantier",
        "definition": { "name": { "fr": "Cours Sécurité chantier" } }
      }]
    }
  }
}

Dans le contexte, il est également possible d’ajouter d’autres attributs comme l’équipe, le formateur etc.. la liste complète se trouve ici

On voit alors qu’xAPI apporte une trace précise avec le contexte de l’objet. Dans cet article l’objet est souvent une activité avec une interaction de type booléen, mais il est évident que l’on peut couvrir beaucoup d’autre cas d’usage avec l’acteur, le verbe, le résultat et le contexte.

Ajouter des extensions

Les extensions permettent d’ajouter du contexte supplémentaire qui n’existe pas dans la spécification. C’est ici que l’on peut ajouter des information métier, la classe ou la cohorte de l’étudiant, des informations supplémentaires sur l’étudiant, un lien LTI launch, la difficulté etc…

Les extensions sont des paires clé/valeur identifiées par une IRI :

"context": {
  "extensions": {
    "https://example.com/xapi/extensions/difficulty": "hard",
    "https://example.com/xapi/extensions/device": "VR-headset"
  }
}

Les extensions peuvent apparaître à trois endroits dans un statement :

dans context.extensions, dans result.extensions, ou dans object.definition.extensions selon ce qu’on souhaite décrire.

Un usage trop libre des extensions conduit au même problème d’interopérabilité que pour les verbes, deux systèmes qui n’utilisent pas les mêmes IRI d’extension ne peuvent pas se comprendre. Si le nombre d’extensions devient important et qu’elles se retrouvent dans la majorité des traces, il vaut mieux créer un xAPI profile

Attacher des fichiers aux traces

Il est fréquent d’avoir besoin de lier des fichiers à une trace d’apprentissage. xAPI propose la propriété attachments. C’est un tableau d’objets contenant principalement des métadonnées sur le fichier : son type, sa taille, son hash SHA-2 pour vérifier son intégrité, et surtout son usageType.

Le usageType est une IRI qui indique pourquoi ce fichier est attaché à la trace — pas seulement ce qu’il est. Par exemple, un PDF peut être un certificat, un rendu d’exercice, ou une pièce justificative. C’est le usageType qui le précise.

{
  "actor": {
    "objectType": "Agent",
    "name": "Marie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/completed",
    "display": {
      "fr-FR": "a terminé",
      "en-US": "completed"
    }
  },
  "object": {
    "id": "http://example.com/exercices/video-question-1",
    "definition": {
      "name": {
        "fr-FR": "Exercice vidéo avec question vrai/faux"
      },
      "description": {
        "fr-FR": "Regarder une vidéo puis répondre à une question vrai/faux"
      },
      "type": "http://adlnet.gov/expapi/activities/cmi.interaction",
      "interactionType": "true-false",
      "correctResponsesPattern": [
        "true"
      ]
    }
  },
  "result": {
    "response": "false",
    "success": false,
    "completion": true,
    "score": {
      "scaled": 0
    }
  },
  "context": {
    "contextActivities": {
      "parent": [
        {
          "id": "http://example.com/activites/module-video"
        }
      ]
    }
  },
  "attachments": [
    {
      "usageType": "http://adlnet.gov/expapi/attachments/supporting_media",
      "display": {
        "fr-FR": "Vidéo de l'exercice"
      },
      "description": {
        "fr-FR": "Vidéo utilisée dans l'exercice"
      },
      "contentType": "video/mp4",
      "length": 12345678,
      "sha2": "3a7bd3e2360a3d80b3d7f6b6e3cbbf4e8c2e7c6a5b4d3e2f1a0b9c8d7e6f5a4b",
      "fileUrl": "http://centreFormationA/videos/exercice.mp4"
    }
  ],
  "timestamp": "2026-03-26T10:00:00Z"
}

un cas d’usage qui revient fréquemment c’est le cas d’un certificat :

Voici un exemple concret : Marie a terminé sa formation sécurité chantier et un certificat PDF lui a été délivré.

{
  "actor": {
    "objectType": "Agent",
    "name": "Marie Dupont",
    "account": {
      "homePage": "https://centreFormationA.fr",
      "name": "ELV-004271"
    }
  },
  "verb": {
    "id": "http://adlnet.gov/expapi/verbs/completed",
    "display": { "fr": "a terminé" }
  },
  "object": {
    "objectType": "Activity",
    "id": "https://centreFormationA.fr/cours/securite-chantier",
    "definition": {
      "name": { "fr": "Cours Sécurité chantier" }
    }
  },
  "attachments": [
    {
      "usageType": "http://adlnet.gov/expapi/attachments/completion_certificate",
      "display": { "fr": "Certificat de completion" },
      "description": { "fr": "Certificat PDF délivré à Marie Dupont le 19 mars 2025" },
      "contentType": "application/pdf",
      "length": 23450,
      "sha2": "a1b2c3d4e5f6...",
      "fileUrl": "https://centreFormationA.fr/certificats/marie-dupont-securite-2025.pdf"
    }
  ]
}

L’attribut sha2 (SHA2 - WIKIPEDIA) permet de vérifier l’intégrité du fichier attaché. Cela peut-être des valeurs SHA-256, SHA-384, SHA-512.

pour calculer cette fonction de hashage vous pouvez taper la commande suivante sur des système unix :

sha256sum marie-dupont-securite-2025.pdf
sha512 exercice.mp4

Signer une trace

La signature sert à déplacer la confiance d’un accord humain vers une preuve technique utile dès qu’il y a de l’argent, du risque juridique, ou un tiers à convaincre.Sans signature, une trace xAPI est une déclaration, avec signature, elle devient une preuve.

Par exemple Une entreprise dans un secteur réglementé (nucléaire, aviation, pharmacie, finance) doit prouver à un régulateur externe qu’une formation a bien eu lieu, que c’est bien cette personne qui l’a suivie, et que personne n’a modifié le résultat après coup. Sans signature, un auditeur peut légitimement contester les traces. Avec signature, elles ont valeur de preuve. Par exemple, si une trace exprime Paul à réussi l’exercice 3445 s’il y a besoin de le prouver techniquement xAPI offre la possibilité d’intégrer la notion de Digital Signature.

Une Digital Signature est insérer dans la trace comme un fichier dans la propriété attachment :

le Json Web Signature (JWS) n’est pas inclus dans la trace mais attaché à cette trace.

Voici les étapes à suivre pour créer une signature, à ma connaissance il n’existe pas d’outils standard

  1. La trace doit être transformée en une chaîne JSON strictement identique à celle qui sera envoyée, cela inclut :

    • l’ordre des champs
    • les espaces
    • les retours à la ligne
    • l’encodage (UTF-8)

  2. Construire le JWS Header

Créer un en-tête JSON contenant :

  1. Encoder en Base64URL

Encoder séparément le header et le payload (la trace sérialisée) puis concaténer :

BASE64URL(header) + "." + BASE64URL(payload)
  1. Signer avec la clé privée

Signer le résultat avec une clé privée (RSA) :

signature = SIGN(data, private_key)
  1. Construire le JWS

Assembler :

JWS = BASE64URL(header) + "." + BASE64URL(payload) + "." + BASE64URL(signature)
  1. Ajouter la signature à la trace

La signature est ajoutée comme un attachment :

La signature (JWS) n’est pas incluse directement dans le JSON du statement.

Elle est envoyée séparément, généralement via une requête HTTP multipart :

Le champ attachments dans le JSON ne contient que les métadonnées permettant de décrire et vérifier cette signature.

Annuler une trace

Une trace peut-être annulée, il suffit d’envoyer une nouvelle trace avec pour verbe voided et d’ajouter en statementRef l’identifiant de la trace qu’on souhaite annuler.

Voici un exemple de statement qui annule le stantement dont l’id est e05aa883-acaf-40ad-bf54-02c8ce485fb0

{
	"actor" : {
		"objectType": "Agent",
		"name" : "Example Admin",
		"mbox" : "mailto:admin@example.adlnet.gov"
	},
	"verb" : {
		"id":"http://adlnet.gov/expapi/verbs/voided",
		"display":{
			"en-US":"voided"
		}
	},
	"object" : {
		"objectType":"StatementRef",
		"id" : "e05aa883-acaf-40ad-bf54-02c8ce485fb0"
	}
}

Learning record Store

On a vu comment est construit une trace et les données que l’on peut y intégrer. Nous allons voir dans cette section comment stocker et récupérer un statement xAPI.

Les statements sont stockés dans un Learning Record Store (LRS). Il s’agit d’une application qui doit s’assurer de la conformité de la trace avant de la stocker et de pouvoir répondre à des requêtes pour récupérer les traces souhaitées.

Source de données
Source de données

Une grande force d’xAPI est la capacité à être indépendant d’un LMS. En effet, la production des traces peut se faire sans LMS :

L’exploitation des traces peut également se faire sans LMS. En effet, un LRS offre une API Rest, un statement est au format JSON. Ainsi, tout outils de visualisation de données capables d’interroger une API et interpréter du JSON sont techniquement capable d’exploiter des traces xAPI. C’est bien sûr possible d’avoir un LMS qui produit des statement et qui exploite directement ces traces mais on peut avoir plusieurs scénarios possible, par exemple un simulateur VR envoie des traces à un LRS et ces traces sont analysées dans Power Bi ou un système d’intelligence artificielle dans ce scénario le LMS n’intervient pas.

Le rôle du LRS est de fournir une abstraction des outils en offrant les possibilités suivantes :

Vous trouverez la spécification pour un LRS ici

XAPI Profile

Si xAPI définit une structure générique de trace (acteur, verbe, objet, résultat, contexte), il n’impose aucune contrainte sur le vocabulaire utilisé, ni sur la manière d’interpréter les événements collectés. Cette liberté, si elle facilite l’adoption du standard dans des contextes variés, conduit rapidement à une hétérogénéité sémantique rendant les traces difficilement comparables ou exploitables à grande échelle.

Afin de répondre à ce problème, l’ADL introduit la notion de xAPI Profiles. Un profil xAPI est un ensemble de règles et de conventions décrivant, pour un contexte donné, les verbes autorisés, les types d’objets, les extensions attendues, ainsi que les relations sémantiques entre ces éléments. L’objectif n’est pas de restreindre xAPI dans son ensemble, mais de contraindre son usage localement afin de produire des traces interprétables et partageables. Les profils permettent de définir un vocabulaire commun (verbes, activités, résultats) un exemple d’un profil XAPI pour le projet Smart vidéo, développé par Loria (Profil XAPI - Smart Vidéo).

Dans cette logique, ADL met à disposition un registre officiel de profils et de vocabulaires, ainsi qu’un Profile Server permettant de publier, valider et réutiliser des profils xAPI (Accès aux registres).

Conclusion

xAPI propose un modèle extrêmement flexible pour tracer l’apprentissage sans être dépendant d’un LMS.

Cependant, cette flexibilité a un coût : sans conventions (profiles, vocabulaire), les traces peuvent devenir difficiles à exploiter.

Mais la limite la plus profonde d’xAPI n’est pas technique. xAPI est muet sur ce que la trace signifie réellement. Il enregistre qu’une action a eu lieu, pas pourquoi elle a eu lieu, ni ce qu’elle révèle de l’apprentissage de l’apprenant. La qualité d’une trace dépend avant tout des choix conceptuels de ceux qui l’ont conçue : ce qu’ils ont décidé de mesurer, comment ils ont modélisé l’activité, et ce qu’ils ont choisi d’ignorer.

xAPI comme les autres standard pour concevoir les traces renforce le rôle des formateurs, enseignants, ingénieurs pédagogique afin de les interpréter et leur donner du sens dans un contexte réel.

Partager