> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Schéma JSON des données utilisateur pour l’importation en bloc d’utilisateurs

> Consultez le schéma JSON et la description des propriétés des données utilisateur utilisées pour l’importation en bloc.

Le fichier de données utilisateur utilisé pour l’importation en bloc d’utilisateurs doit être au format JSON. Il doit contenir un tableau d’objets utilisateur correspondant au schéma indiqué.

<div id="user-json-schema">
  ## Schéma JSON des utilisateurs
</div>

Le [schéma JSON](https://json-schema.org) suivant décrit les utilisateurs valides :

```json lines expandable theme={null}
{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "The user's email address.",
      "format": "email"
    },
    "email_verified": {
      "type": "boolean",
      "default": false,
      "description": "Indicates whether the user has verified their email address."
    },
    "user_id": {
      "type": "string",
      "description": "The user's unique identifier. This will be prepended by the connection strategy."
    },
    "username": {
      "type": "string",
      "description": "The user's username."
    },
    "given_name": {
      "type": "string",
      "description": "The user's given name."
    },
    "family_name": {
      "type": "string",
      "description": "The user's family name."
    },
    "name": {
      "type": "string",
      "description": "The user's full name."
    },
    "nickname": {
      "type": "string",
      "description": "The user's nickname."
    },
    "picture": {
      "type": "string",
      "description": "URL pointing to the user's profile picture."
    },
    "blocked": {
      "type": "boolean",
      "description": "Indicates whether the user has been blocked."
    },
    "password_hash": {
      "type": "string",
      "description": "Hashed password for the user. Passwords should be hashed using bcrypt $2a$ or $2b$ and have 10 saltRounds."
    },
    "custom_password_hash": {
      "type": "object",
      "description": "A more generic way to provide the users password hash. This can be used in lieu of the password_hash field when the users password hash was created with an alternate algorithm. Note that this field and password_hash are mutually exclusive.",
      "properties": {
        "algorithm": {
          "type": "string",
          "enum": [
            "argon2",
            "bcrypt",
            "hmac",
            "ldap",
            "md4",
            "md5",
            "sha1",
            "sha256",
            "sha512",
            "pbkdf2",
            "scrypt"
          ],
          "description": "The algorithm that was used to hash the password."
        },
        "hash": {
          "type": "object",
          "properties": {
            "value": {
              "type": "string",
              "description": "The password hash."
            },
            "encoding": {
              "type": "string",
              "enum": [
                "base64",
                "hex",
                "utf8"
              ],
              "description": "The encoding of the provided hash. Note that both upper and lower case hex variants are supported, as well as url-encoded base64."
            },
            "digest": {
              "type": "string",
              "description": "The algorithm that was used to generate the HMAC hash",
              "enum": [
                "md4",
                "md5",
                "ripemd160",
                "sha1",
                "sha224",
                "sha256",
                "sha384",
                "sha512",
                "whirlpool"
              ]
            },
            "key": {
              "type": "object",
              "description": "The key that was used to generate the HMAC hash",
              "required": [
                "value"
              ],
              "properties": {
                "value": {
                  "type": "string",
                  "description": "The key value"
                },
                "encoding": {
                  "type": "string",
                  "enum": [
                    "base64",
                    "hex",
                    "utf8"
                  ],
                  "default": "utf8",
                  "description": "The key encoding"
                }
              }
            }
          }
        },
        "salt": {
          "type": "object",
          "properties": {
            "value": {
              "type": "string",
              "description": "The salt value used to generate the hash."
            },
            "encoding": {
              "type": "string",
              "enum": [
                "base64",
                "hex",
                "utf8"
              ],
              "default": "utf8",
              "description": "The encoding of the provided salt. Note that both upper and lower case hex variants are supported, as well as url-encoded base64."
            },
            "position": {
              "type": "string",
              "enum": [
                "prefix",
                "suffix"
              ],
              "default": "prefix",
              "description": "The position of the salt when the hash was calculated. For example; MD5('salt' + 'password') = '67A1E09BB1F83F5007DC119C14D663AA' would have \"position\":\"prefix\"."
            }
          },
          "required": [
            "value"
          ]
        },
        "password": {
          "type": "object",
          "properties": {
            "encoding": {
              "type": "string",
              "enum": [
                "ascii",
                "utf8",
                "utf16le",
                "ucs2",
                "latin1",
                "binary"
              ],
              "default": "utf8",
              "description": "The encoding of the password used to generate the hash. On login, the user-provided password will be transcoded from utf8 before being checked against the provided hash. For example; if your hash was generated from a ucs2 encoded string, then you would supply \"encoding\":\"ucs2\"."
            }
          }
        },
        "keylen": {
          "type": "integer",
          "description": "Desired key length in bytes for the scrypt hash. Must be an integer greater than zero. Required when algorithm is set to scrypt."
        },
        "cost": {
          "type": "integer",
          "default": 16384,
          "description": "CPU/memory cost parameter used for the scrypt hash. Must be a power of two greater than one. Only used when algorithm is set to scrypt."
        },
        "blockSize": {
          "type": "integer",
          "default": 8,
          "description": "Block size parameter used for the scrypt hash. Must be a positive integer. Only used when algorithm is set to scrypt."
        },
        "parallelization": {
          "type": "integer",
          "default": 1,
          "description": "Parallelization parameter used for the scrypt hash. Must be a positive integer. Only used when algorithm is set to scrypt."
        }
      },
      "required": [
        "algorithm",
        "hash"
      ],
      "additionalProperties": false
    },
    "app_metadata": {
      "type": "object",
      "description": "Data related to the user that does affect the application's core functionality."
    },
    "user_metadata": {
      "type": "object",
      "description": "Data related to the user that does not affect the application's core functionality."
    },
    "mfa_factors": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "totp": {
            "type": "object",
            "properties": {
              "secret": {
                "type": "string",
                "pattern": "^[A-Z2-7]+$",
                "description": "The OTP secret is used with authenticator apps (Google Authenticator, Microsoft Authenticator, Authy, 1Password, LastPass). It must be supplied in un-padded Base32 encoding, such as: JBTWY3DPEHPK3PNP"
              }
            },
            "additionalProperties": false,
            "required": [
              "secret"
            ]
          },
          "phone": {
            "type": "object",
            "properties": {
              "value": {
                "type": "string",
                "pattern": "^\\+[0-9]{1,15}$",
                "description": "The phone number for SMS MFA. The phone number should include a country code and begin with +, such as: +12125550001"
              }
            },
            "additionalProperties": false,
            "required": [
              "value"
            ]
          },
          "email": {
            "type": "object",
            "properties": {
              "value": {
                "type": "string",
                "format": "email",
                "description": "The email address for MFA"
              }
            },
            "additionalProperties": false,
            "required": [
              "value"
            ]
          }
        },
        "maxProperties": 1,
        "additionalProperties": false
      },
      "minItems": 1,
      "maxItems": 10
    }
  },
  "required": [
    "email"
  ],
  "additionalProperties": false
}
```

<div id="user-object-properties">
  ## Propriétés de l’objet `user`
</div>

<ResponseField name="app_metadata" type="object" post={ [ "upsertable" ] }>
  Données pouvant influer sur les fonctionnalités de base de l’application ou sur les ressources auxquelles l’utilisateur peut accéder. Les données stockées dans `app_metadata` ne peuvent pas être modifiées par les utilisateurs. Elles peuvent notamment comprendre des plans de soutien, des rôles ou des groupes d’accès.

  Pour en savoir plus sur les métadonnées, consultez [Comprendre le fonctionnement des métadonnées dans les profils utilisateur](/docs/fr-ca/manage-users/user-accounts/metadata).

  <Expandable title="propriétés interdites">
    `app_metadata` ne peut pas contenir les propriétés suivantes :

    * `__tenant`
    * `_id`
    * `blocked`
    * `clientID`
    * `created_at`
    * `email_verified`
    * `email`
    * `globalClientID`
    * `global_client_id`
    * `identities`
    * `lastIP`
    * `lastLogin`
    * `loginsCount`
    * `metadata`
    * `multifactor_last_modified`
    * `multifactor`
    * `updated_at`
    * `user_id`
  </Expandable>
</ResponseField>

<ResponseField name="blocked" type="boolean">
  Indique si l’utilisateur a été bloqué.
</ResponseField>

<ResponseField name="email" type="string" required>
  L’adresse courriel de l’utilisateur.
</ResponseField>

<ResponseField name="email_verified" type="boolean" default={false} post={ ["upsertable"] }>
  Indique si l’utilisateur a vérifié son adresse courriel. Cette valeur est définie à `false` par défaut si `email`, mais non `email_verified`, est mis à jour par upsert.
</ResponseField>

<ResponseField name="family_name" type="string" post={ ["upsertable"] }>
  Le nom de famille de l’utilisateur.
</ResponseField>

<ResponseField name="given_name" type="string" post={ ["upsertable"] }>
  Le prénom de l’utilisateur.
</ResponseField>

<ResponseField name="name" type="string" post={ ["upsertable"] }>
  Le nom complet de l’utilisateur.
</ResponseField>

<ResponseField name="nickname" type="string" post={ ["upsertable"] }>
  Le surnom de l’utilisateur.
</ResponseField>

<ResponseField name="picture" type="string" post={ ["upsertable"] }>
  URL de la photo de profil de l’utilisateur.
</ResponseField>

<ResponseField name="user_id" type="string">
  L’identifiant unique de l’utilisateur. Il est précédé de la stratégie de connexion.
</ResponseField>

<ResponseField name="user_metadata" type="object" post={ ["upsertable"] }>
  Données qui n’ont aucune incidence sur les ressources auxquelles les utilisateurs peuvent accéder, comme l’adresse professionnelle, l’adresse domiciliaire ou les préférences de l’utilisateur.

  Pour en savoir plus sur les métadonnées, consultez [Comprendre le fonctionnement des métadonnées dans les profils utilisateur](/docs/fr-ca/manage-users/user-accounts/metadata).
</ResponseField>

<ResponseField name="username" type="string">
  Le nom d’utilisateur de l’utilisateur.
</ResponseField>

<ResponseField name="password_hash" type="string">
  Mot de passe haché de la connexion de l’utilisateur.

  Lors de la création des utilisateurs, Auth0 utilise [bcrypt](https://auth0.com/blog/hashing-in-action-understanding-bcrypt/) pour sécuriser les mots de passe. L’importation de mots de passe hachés permet aux utilisateurs de conserver leurs mots de passe pour une expérience plus fluide. Les mots de passe compatibles doivent être hachés à l’aide de bcrypt `$2a$` ou `$2b$` et utiliser 10 saltRounds.

  Cette propriété ne peut être fournie que lors de la première importation de l’utilisateur et ne peut pas être mise à jour par la suite.
</ResponseField>

<ResponseField name="custom_password_hash" type="object" post={ ["upsertable"] }>
  Une méthode plus générale pour fournir le hachage du mot de passe de l’utilisateur.

  Vous pouvez utiliser ce champ au lieu du champ `password_hash` lorsque le hachage du mot de passe de l’utilisateur a été créé avec un autre algorithme. Ce champ et `password_hash` sont mutuellement exclusifs.

  Lors de l’importation en bloc, vous pouvez mettre à jour le `custom_password_hash` si l’utilisateur ne s’est pas connecté à l’aide du `custom_password_hash` importé initialement.

  <Expandable title="enfants">
    <ResponseField name="algorithme" type="string" required>
      L’algorithme utilisé pour hacher le mot de passe.

      Auth0 prend en charge les algorithmes suivants :

      <Tabs>
        <Tab title="Argon2">
          Lorsque `algorithm` est défini sur [`argon2`](https://github.com/p-h-c/phc-winner-argon2) :

          * `hash.encoding` doit être `utf8`.
          * `hash.salt` n’est pas autorisé.
          * `hash.value` doit être au format de chaîne PHC, tel que défini dans [P-H-C / phc-string-format](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md) sur GitHub. Il doit également respecter les exigences définies dans [Auth0 / magic](https://github.com/auth0/magic#magicpasswordhash--magicverifypassword) sur GitHub.
          * `hash.value` doit inclure le salt encodé en base64 (tel que défini dans la documentation `PHC`).
        </Tab>

        <Tab title="bcrypt">
          Lorsque `algorithm` est défini sur [`bcrypt`](https://auth0.com/blog/hashing-in-action-understanding-bcrypt/) :

          * `hash.encoding` doit être `utf8`.
          * `hash.salt` est autorisé avec l’encodage et la position du sel.
          * `hash.value` doit inclure l’un de ces préfixes :

            * `$2a$`
            * `$2b$`
            * `$2y$`

            Les autres préfixes, comme `$2$`, `$sha1$` et `$2x$`, ne sont pas pris en charge pour le moment.

          Par exemple, cette valeur a été générée à partir de la chaîne `hello` avec un paramètre de coût de 10 : `$2b$10$nFguVi9LsCAcvTZFKQlRKeLVydo8ETv483lkNsSFI/Wl1Rz1Ypo1K`

          L’algorithme `bcrypt` traite au maximum 72 octets d’entrée lors du calcul ou de la comparaison des hachages de mots de passe, et la longueur de `salt.value` est prise en compte dans cette limite de 72 octets. Toute entrée qui dépasse cette limite est tronquée. Par exemple, si le sel occupe 10 octets, la longueur maximale du mot de passe pour le hachage ou la comparaison est de 62 octets.

          Les mots de passe qui dépassent cette limite réduite sont tronqués, ce qui peut affaiblir leur robustesse ou entraîner des collisions de hachage. Validez toujours la longueur des mots de passe avant le hachage.
        </Tab>

        <Tab title="HMAC">
          Lorsque `algorithm` est défini à [`hmac`](https://tools.ietf.org/html/rfc2104) :

          * `hash.encoding` doit être `hex` ou `base64`.
          * `hash.digest` est obligatoire et doit être l’un des suivants :
            * `md4`
            * `md5`
            * `ripemd160`
            * `sha1`
            * `sha224`
            * `sha256`
            * `sha384`
            * `sha512`
            * `whirlpool`
          * `hash.key.value` est obligatoire.
          * `hash.key.encoding` doit être `base64`, `hex` ou `utf8`.
        </Tab>

        <Tab title="LDAP">
          Lorsque `algorithm` est défini à [`ldap`](https://tools.ietf.org/html/rfc2307#section-5.3) (`RFC-2307 "userPassword"`) :

          * `hash.encoding` doit être `utf8`.
          * `hash.salt` n’est pas autorisé.
          * `hash.value` doit respecter le format décrit à la [section 5.3 de la RFC-2307](https://tools.ietf.org/html/rfc2307#section-5.3) sur IETF Datatracker.
          * Le schéma doit être l’un des suivants : `md5|smd5|sha*|ssha*`. Consultez [cette page](https://www.openldap.org/faq/data/cache/347.html) pour en savoir plus.
            Le schéma [crypt](https://www.openldap.org/faq/data/cache/344.html) n’est **pas pris en charge** en raison d’un comportement qui dépend du système et de la mise en œuvre. Pour en savoir plus, consultez [Open LDAP Admin Guide - 14.4.2. CRYPT password storage scheme](https://www.openldap.org/doc/admin24/guide.html#CRYPT%20password%20storage%20scheme).
        </Tab>

        <Tab title="MD et SHA">
          Lorsque `algorithm` est défini sur [`md4`](https://tools.ietf.org/html/rfc1320), [`md5`](https://tools.ietf.org/html/rfc1321), [`sha1`](https://tools.ietf.org/html/rfc3174), [`sha256`](https://tools.ietf.org/html/rfc4634) ou [`sha512`](https://tools.ietf.org/html/rfc4634) :

          * `hash.encoding` doit être égal à `hex` ou à `base64`.
        </Tab>

        <Tab title="PBKDF2">
          Lorsque `algorithm` est défini sur [`pbkdf2`](https://tools.ietf.org/html/rfc2898#section-5.2) :

          * `hash.encoding` doit être `utf8`.
          * `hash.salt` n’est pas permis.
          * `hash.value` devrait être au format de chaîne PHC, tel que spécifié dans [P-H-C / phc-string-format](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md) sur GitHub.
          * `hash.value` doit inclure le salt encodé en B64 (base64 sans les caractères de remplissage `=`, comme indiqué dans la documentation `PHC`).
          * `hash.value` devrait inclure les paramètres `i` (itérations) et `l` (longueur de clé). Si ces paramètres sont omis, les valeurs par défaut sont `i=100000` et `l=64`.
          * `id` devrait être au format `pbkdf2-<digest>` (`pbkdf2-sha512`, `pbkdf2-md5`, etc.). Les condensats pris en charge sont :
            * `RSA-MD4`
            * `RSA-MD5`
            * `RSA-MDC2`
            * `RSA-RIPEMD160`
            * `RSA-SHA1`
            * `RSA-SHA1-2`
            * `RSA-SHA224`
            * `RSA-SHA256`
            * `RSA-SHA384`
            * `RSA-SHA512`
            * `md4`
            * `md4WithRSAEncryption`
            * `md5`
            * `md5WithRSAEncryption`
            * `mdc2`
            * `mdc2WithRSA`
            * `ripemd`
            * `ripemd160`
            * `ripemd160WithRSA`
            * `rmd160`
            * `sha1`
            * `sha1WithRSAEncryption`
            * `sha224`
            * `sha224WithRSAEncryption`
            * `sha256`
            * `sha256WithRSAEncryption`
            * `sha384`
            * `sha384WithRSAEncryption`
            * `sha512`
            * `sha512WithRSAEncryption`
            * `ssl3-md5`
            * `ssl3-sha1`
            * `whirlpool`
        </Tab>

        <Tab title="scrypt">
          Lorsque `algorithm` est défini sur [`scrypt`](https://datatracker.ietf.org/doc/rfc7914/) :

          * `hash.encoding` doit être `hex` ou `base64`.

          <ResponseField name="keylen" type="integer" required>
            Longueur de clé souhaitée, en octets, pour le hachage scrypt. Doit être un entier supérieur à zéro.
          </ResponseField>

          <ResponseField name="cost" type="integer" default={16384}>
            Paramètre de coût CPU/mémoire utilisé pour le hachage scrypt. Doit être une puissance de deux supérieure à un.
          </ResponseField>

          <ResponseField name="blockSize" type="integer" default={8}>
            Paramètre de taille de bloc utilisé pour le hachage scrypt. Doit être un entier positif.
          </ResponseField>

          <ResponseField name="parallelization" type="integer" default={1}>
            Paramètre de parallélisation utilisé pour le hachage scrypt. Doit être un entier positif.
          </ResponseField>
        </Tab>
      </Tabs>
    </ResponseField>

    <ResponseField name="hachage" type="object" required>
      <Expandable title="children">
        <ResponseField name="value" type="string">
          Le hachage du mot de passe.
        </ResponseField>

        <ResponseField name="encoding" type="string">
          L’encodage du hachage fourni. Doit être l’un des suivants : <ul><li>`base64`</li><li>`hex`</li><li>`utf8`</li></ul>Les variantes hexadécimales en majuscules et en minuscules sont prises en charge, de même que le base64 encodé dans une URL.
        </ResponseField>

        <ResponseField name="digest" type="string">
          L’algorithme utilisé pour générer le hachage HMAC. Doit être l’un des suivants : <ul><li>`md4`</li><li>`md5`</li><li>`ripemd160`</li><li>`sha1`</li><li>`sha224`</li><li>`sha256`</li><li>`sha384`</li><li>`sha512`</li><li>`whirlpool`</li></ul>
        </ResponseField>

        <ResponseField name="key" type="object">
          La clé utilisée pour générer le hachage HMAC.

          <Expandable title="children">
            <ResponseField name="value" type="string" required>
              La valeur de la clé.
            </ResponseField>

            <ResponseField name="encoding" type="string" default="utf8">
              L’encodage de la clé. Doit être l’un des suivants : <ul><li>`base64`</li><li>`hex`</li><li>`utf8`</li></ul>
            </ResponseField>
          </Expandable>
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="sel" type="object">
      <Expandable title="children">
        <ResponseField name="value" type="string" required>
          La valeur du salt utilisée pour générer le hachage.
        </ResponseField>

        <ResponseField name="encoding" type="string" default="utf8">
          L’encodage du salt fourni. Doit être l’un des suivants : <ul><li>`base64`</li><li>`hex`</li><li>`utf8`</li></ul> Les variantes hexadécimales en majuscules et en minuscules sont prises en charge, de même que le base64 encodé pour les URL.
        </ResponseField>

        <ResponseField name="position" type="string" default="prefix">
          La position du salt au moment du calcul du hachage.
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="mot de passe" type="object">
      <ResponseField name="encoding" type="string" default="utf8">
        L’encodage du mot de passe utilisé pour générer le hachage. Doit être l’un des suivants : <ul><li>`ascii`</li><li>`utf8`</li><li>`utf16le`</li><li>`ucs2`</li><li>`latin1`</li><li>`binary`</li></ul> Lors de la connexion, le mot de passe fourni par l’utilisateur sera transcodé depuis `password.encoding` avant d’être vérifié par rapport au hachage fourni. Par exemple, si votre hachage a été généré à partir d’une chaîne encodée en `ucs2`, vous devez définir : ` "encoding": "ucs2"`
      </ResponseField>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="mfa_factors" type="array">
  L’[authentification multifacteur (MFA)](/docs/fr-ca/secure/multi-factor-authentication) pouvant être utilisée pour authentifier cet utilisateur. L’importation des inscriptions évite aux utilisateurs de devoir s’inscrire de nouveau à la MFA après leur importation.

  Les facteurs d’inscription pris en charge sont le courriel, les SMS et le TOTP.

  <Expandable title="enfants">
    <ResponseField name="email" type="object">
      <ResponseField name="email.value" type="string" required>
        L’adresse courriel utilisée pour la MFA.
      </ResponseField>
    </ResponseField>

    <ResponseField name="phone" type="object">
      <ResponseField name="phone.value" type="string" required>
        Le numéro de téléphone utilisé pour la MFA par SMS. Il doit inclure un indicatif de pays et commencer par `+`, par exemple : `"+12125550001"`.
      </ResponseField>
    </ResponseField>

    <ResponseField name="totp" type="object">
      <ResponseField name="totp.secret" type="string" required>
        Le secret OTP utilisé avec les applications d’authentification (comme Google Authenticator, Microsoft Authenticator, Authy, 1Password ou LastPass). Il doit être encodé en Base32 sans remplissage, par exemple : `"JBTWY3DPEHPK3PNP"`
      </ResponseField>
    </ResponseField>
  </Expandable>
</ResponseField>

<div id="user-data-json-examples">
  ## Exemples JSON de données utilisateur
</div>

<AccordionGroup>
  <Accordion title="Exemple de base">
    Un fichier dont le contenu est le suivant est valide :

    ```json lines theme={null}
    [
      {
        "email": "john.doe@example.com",
        "email_verified": false,
        "app_metadata": {
          "roles": ["admin"],
          "plan": "premium"
        },
        "user_metadata": {
          "theme": "light"
        }
      }
    ]
    ```
  </Accordion>

  <Accordion title="Exemples de hachages de mots de passe personnalisés">
    Exemples d’utilisateurs avec les hachages fournis :

    ```json lines expandable theme={null}
    [
      {
        "email": "antoinette@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "md4",
          "hash": {
            "value": "AbuUujgF0pPPkJPSFRTpmA==",
            "encoding": "base64"
          }
        }
      },
      {
        "email": "mary@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "sha256",
          "hash": {
            "value": "d24e794fce503c3ddb1cd1ba1dd5d9b250cf9917336a0316fefd87fecf79200f",
            "encoding": "hex"
          },
          "salt": {
            "value": "abc123",
            "position": "prefix"
          }
        }
      },
      {
        "email": "velma@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "bcrypt",
          "hash": {
            "value": "$2b$10$C9hB01.YxRSTcn/ZOOo4j.TW7xCKKFKBSF.C7E0xiUwumqIDqWUXG"
          }
        }
      },
      {
        "email": "edward@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "argon2",
          "hash": {
            "value": "$argon2id$v=19$m=65536,t=2,p=1$J6Q/82PCyaNpYKRELJyTZg$m04qUAB8rexWDR4+/0f+SFB+4XMFxt7YAvAq2UycYos"
          }
        }
      },
      {
        "email": "terrell@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "pbkdf2",
          "hash": {
            "value": "$pbkdf2-md4$i=100000,l=64$+N375B8q0Fw$fp2R9KAM4hK/votGHC5Fu+jhqbxUD8+Nic/EMSGvNC3UP/k7wSHI0uXluHRSkZfl/BOheYqNOemayG90ZaSSQw",
            "encoding": "utf8"
          }
        }
      },
      {
        "email": "cecil@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "pbkdf2",
          "hash": {
            "value": "$pbkdf2-sha512$i=100000,l=64$KNyFsA2rWoE$I2CQGI9H0JxdDf3kERRI97kPCGxh0KWBIV3MxyaS191gDGfzVBGyS4BibhgqWQ0/ails8mHuU9ckASxHOOq58w"
          }
        }
      },
      {
        "email": "sean@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "ldap",
          "hash": {
            "value": "{SSHA384}/cgEjdoZh85DhurDeOQEMO1rMlAur93SVPbYe5XSD4lF7nNuvrBju5hUeg9A6agRemgSXGl5YuE=",
            "encoding": "utf8"
          }
        }
      },
      {
        "email": "peter@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "hmac",
          "hash": {
            "value": "cg7f42jH39/2EaAU4wNd4s2lKIk=",
            "encoding": "base64",
            "digest": "sha1",
            "key": {
              "value": "736868",
              "encoding": "hex"
            }
          }
        }
      },
      {
        "email": "carmella@example.com",
        "email_verified": false,
        "custom_password_hash": {
          "algorithm": "scrypt",
          "hash": {
            "value": "097f6197e1b41538f723e32aa7a68e8d76227d8e432ce5faa4882a913032db29",
            "encoding": "hex"
          },
          "salt": {
            "value": "abc123",
            "encoding": "utf8"
          },
          "keylen": 32,
          "cost": 4096
        }
      }
    ]
    ```
  </Accordion>

  <Accordion title="Exemples de facteurs d’AMF">
    Quelques exemples d’utilisateurs avec des facteurs MFA :

    ```json lines expandable theme={null}
    [
      {
        "email": "antoinette@example.com",
        "mfa_factors": [
          {
            "totp": {
              "secret": "2PRXZWZAYYDAWCD"
            }
          },
          {
            "phone": {
              "value": "+15551112233"
            }
          },
          {
            "email": {
              "value": "antoinette@example.org"
            }
          }
        ]
      },
      {
        "email": "mary@example.com",
        "mfa_factors": [
          {
            "totp": {
              "secret": "JBTWY3DPEHPK3PNP"
            }
          }
        ]
      },
      {
        "email": "velma@example.com",
        "mfa_factors": [
          {
            "phone": {
              "value": "+15551234567"
            }
          },
        ]
      },
      {
      "email": "edward@example.com",
        "mfa_factors": [
          {
            "email": {
              "value": "edward@example.org"
            }
          }
        ]
      }
    ]
    ```
  </Accordion>
</AccordionGroup>