> ## 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.

> Décrit quelles fonctionnalités d’Auth0 peuvent vous aider à vous conformer aux exigences du RGPD relatives aux conditions du consentement.

# RGPD : conditions du consentement

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Conformément à l’article 7 du RGPD, vous devez demander aux utilisateurs de consentir au traitement de leurs données personnelles de façon claire et facilement accessible. Vous devez également être en mesure de démontrer que l’utilisateur a donné son consentement et offrir un moyen simple de le retirer en tout temps.

Cet article explique comment utiliser les fonctionnalités d’Auth0 pour mettre en œuvre ces exigences.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Le contenu de ces documents ne constitue pas un avis juridique et ne doit pas non plus être considéré comme un substitut à une assistance juridique. Il vous incombe en dernier ressort de comprendre le RGPD et de vous y conformer, bien qu’Auth0 vous aide, dans la mesure du possible, à respecter les exigences du RGPD.
</Callout>

<div id="ask-for-consent">
  ## Demander le consentement
</div>

Lors de l’inscription, vous devez obtenir le consentement de vos utilisateurs. Avec Auth0, vous pouvez enregistrer cette information dans les métadonnées de l’utilisateur. Plusieurs options sont offertes selon la façon dont vous utilisez Auth0 pour authentifier vos utilisateurs. Avant de concevoir votre solution à l’aide des métadonnées, assurez-vous de connaître les restrictions. Auth0 limite la taille totale de `user_metadata` à **16 MB**. Pour en savoir plus, consultez [Noms de champs et types de données des métadonnées](/docs/fr-ca/manage-users/user-accounts/metadata/metadata-fields-data).

<Warning>
  Les métadonnées d’Auth0 ne constituent pas un stockage de données sécurisé et ne doivent pas être utilisées pour stocker des informations sensibles, comme des secrets à haut risque et des renseignements personnels (PII), tels que les numéros d’assurance sociale ou de carte de crédit. Auth0 recommande fortement à ses clients d’évaluer les données stockées dans les métadonnées et de n’y conserver que celles qui sont nécessaires aux fins de la gestion des identités et des accès.
</Warning>

<div id="use-lock">
  ### Utiliser Lock
</div>

Vous pouvez personnaliser l’interface Lock UI pour afficher des liens vers vos pages de conditions générales et/ou d’énoncé de confidentialité, ainsi qu’une case de consentement que l’utilisateur doit cocher pour pouvoir s’inscrire. Pour ce faire, utilisez l’option Lock `mustAcceptTerm`s. Lorsque cette propriété est définie sur `true`, une case à cocher s’affiche à côté des conditions générales et doit être cochée avant l’inscription. Les conditions générales peuvent être précisées à l’aide de l’option `languageDictionary`. Pour en savoir plus, consultez [Options de configuration de Lock](/docs/fr-ca/libraries/lock/lock-configuration).

Une fois que l’utilisateur a accepté et qu’il s’est inscrit, enregistrez les renseignements sur le consentement dans `user_metadata` à l’aide d’une règle qui s’exécutera lors de la première connexion. Pour en savoir plus sur les règles, consultez [Auth0 Rules](/docs/fr-ca/customize/rules).

Si vous souhaitez obtenir plus d’information de la part des utilisateurs pendant l’inscription et que vous les authentifiez au moyen d’une connexion de base de données, vous pouvez ajouter des champs personnalisés à l’interface Lock UI. Pour ce faire, utilisez l’option Lock `additionalSignUpFields`. Tous les champs personnalisés sont automatiquement ajoutés à `user_metadata`.

Si vous utilisez des connexions sociales, il n’est pas possible d’ajouter des champs personnalisés, mais vous pouvez rediriger l’utilisateur vers une autre page pour lui demander son consentement et tout renseignement supplémentaire, puis le rediriger pour terminer la transaction d’authentification. Cela peut se faire avec des règles de redirection. Pour en savoir plus, consultez [Rediriger les utilisateurs à partir des règles](/docs/fr-ca/customize/rules/redirect-users). Une fois le processus d’inscription terminé, enregistrez les renseignements sur le consentement dans `user_metadata` en appelant le <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> point de terminaison [**Update User**](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id).

Pour savoir comment mettre en œuvre l’un de ces scénarios, consultez [GDPR : consigner le consentement avec Lock](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-track-consent-with-lock).

<div id="use-custom-ui">
  ### Utiliser une interface utilisateur personnalisée
</div>

Si vous utilisez un formulaire d’inscription personnalisé avec une connexion de base de données, vous devez ajouter un champ supplémentaire à l’écran d’inscription afin de recueillir le consentement de l’utilisateur. Ensuite, appelez le [**point de terminaison Signup**](https://auth0.com/docs/api/authentication#signup) de l’Authentication API afin de créer l’utilisateur dans Auth0. À cette étape, vous pouvez enregistrer les renseignements sur le consentement dans le `user_metadata`.

Autrement, si vous utilisez auth0.js à partir d’une SPA, vous pouvez [utiliser la méthode `signup`](/docs/fr-ca/libraries/auth0js) afin de créer l’utilisateur dans Auth0 et enregistrer les renseignements sur le consentement dans le `user_metadata`.

Si vous utilisez un formulaire d’inscription personnalisé avec des fournisseurs d’identité sociale, vous ne pouvez pas enregistrer les renseignements sur le consentement de l’utilisateur au moment de l’inscription, mais vous pouvez les mettre à jour dès que l’utilisateur est créé. Enregistrez les renseignements sur le consentement dans le `user_metadata` en appelant le [**point de terminaison Update User**](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id) de la Management API.

Pour savoir comment mettre en œuvre l’un ou l’autre de ces scénarios, consultez [GDPR : Suivre le consentement avec une interface utilisateur personnalisée](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-track-consent-with-custom-ui).

<div id="re-consent-and-user-migration">
  ### Renouvellement du consentement et migration des utilisateurs
</div>

Si vous devez demander le consentement d’utilisateurs existants et que vous décidez de migrer vos utilisateurs d’une base de données existante vers Auth0, vous pouvez [utiliser notre fonctionnalité de migration automatique des utilisateurs](/docs/fr-ca/manage-users/user-migration/configure-automatic-migration-from-your-database). En l’activant, chaque fois qu’un utilisateur ouvrira une session pour la première fois (depuis son activation), son compte sera créé dans Auth0 sans qu’il ait à réinitialiser son mot de passe. Pour ce faire, vous devez :

* Rédiger l’avis que les utilisateurs verront expliquant comment leurs données sont utilisées, pendant combien de temps elles le seront, quels sont leurs droits, etc., ainsi que personnaliser la fenêtre d’inscription de l’interface utilisateur.
* Déterminer si vous devez obtenir de nouveau le consentement de vos utilisateurs, selon vos anciennes conditions générales et vos certifications antérieures en matière de protection de la vie privée.

Notez que chaque fois que vos conditions générales changent, vous **devez** redemander le consentement des utilisateurs.

<div id="track-consent">
  ## Suivi du consentement
</div>

Selon le RGPD, vous devriez être en mesure de démontrer que l’utilisateur a consenti au traitement de ses données personnelles.

Avec Auth0, vous pouvez enregistrer les informations de consentement de l’utilisateur dans le `user_metadata`. Vous pouvez soit enregistrer uniquement un indicateur précisant si l’utilisateur a consenti ou non, soit un ensemble d’informations et de préférences liées au consentement (y compris, par exemple, la date à laquelle l’utilisateur a donné son consentement, les conditions auxquelles il a consenti, etc.). Vous pouvez ensuite accéder à ces informations et les modifier à l’aide de la Management API.

La Management API offre également plusieurs options pour la recherche d’utilisateurs ainsi que des points de terminaison permettant de mettre à jour les métadonnées des utilisateurs ou d’exporter des utilisateurs en lot.

Pour accéder à la Management API, vous aurez besoin d’un <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+token">jeton d’accès</Tooltip>. Pour savoir comment obtenir un jeton d’accès pour la Management API, consultez [Jetons d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens).

<div id="search-for-users-by-email-address">
  ### Rechercher des utilisateurs par adresse courriel
</div>

Pour rechercher un utilisateur à partir de son adresse courriel, utilisez l’[**point de terminaison Search User by Email**](/docs/fr-ca/manage-users/user-search/user-search-best-practices).

Définissez le paramètre de requête **fields** sur `user_metadata` afin de limiter les champs retournés. Ainsi, seules les données user\_metadata seront retournées plutôt que le profil utilisateur complet.

Exemple de requête :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata' \
    --header 'authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.get("https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata")
    .header("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/api/v2/users-by-email',
    params: {email: 'USER_EMAIL_ADDRESS', fields: 'user_metadata'},
    headers: {authorization: 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer YOUR_MGMT_API_ACCESS_TOKEN" }

  conn.request("GET", "/{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users-by-email?email=USER_EMAIL_ADDRESS&fields=user_metadata")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Exemple de réponse :

```json lines theme={null}
[
  {},
  {
    "user_metadata": {
      "consent": {
	    "given": true,
	    "date": "01/23/2018",
	    "text_details": "some-url"
	  }
    }
  }
]
```

<div id="search-for-users-by-id">
  ### Rechercher des utilisateurs par ID
</div>

Pour rechercher un utilisateur par son ID, utilisez l’[point de terminaison **Get a User**](/docs/fr-ca/manage-users/user-search/user-search-best-practices).

Définissez le paramètre de requête **fields** à `user_metadata` afin de limiter les champs renvoyés. Ainsi, seul `user_metadata` sera renvoyé plutôt que l’ensemble du profil utilisateur.

Exemple de requête :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata' \
    --header 'authorization: Bearer {yourMgmtApiAccessToken}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {yourMgmtApiAccessToken}");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer {yourMgmtApiAccessToken}")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.get("https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata")
    .header("authorization", "Bearer {yourMgmtApiAccessToken}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/api/v2/users/%7ByourUserID%7D',
    params: {fields: 'user_metadata'},
    headers: {authorization: 'Bearer {yourMgmtApiAccessToken}'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {yourMgmtApiAccessToken}"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer {yourMgmtApiAccessToken}" }

  conn.request("GET", "/{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/%7ByourUserID%7D?fields=user_metadata")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer {yourMgmtApiAccessToken}'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Exemple de réponse :

```json lines theme={null}
{
  "user_metadata": {
    "consent": {
	    "given": true,
	    "date": "01/23/2018",
	    "text_details": "some-url"
  	}
  }
}
```

<div id="update-consent-information">
  ### Mettre à jour les informations sur le consentement
</div>

Pour mettre à jour le `user_metadata` d’un utilisateur, utilisez le [point de terminaison **Update a User**](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id).

La façon de structurer votre requête dépend de la structure de vos métadonnées : à la racine ou dans des propriétés internes.

Si vos métadonnées sont stockées à la racine :

```json lines theme={null}
{
  "consentGiven": true,
  "consentDetails": "some-url"
}
```

Si vos métadonnées sont stockées sous forme de propriétés internes :

```json lines theme={null}
{
  "consent": {
    "given": true,
    "text_details": "some-url"
  }
}
```

<div id="update-root-property">
  #### Mettre à jour la propriété racine
</div>

Les mises à jour des propriétés de niveau racine sont fusionnées; vous n’avez donc qu’à envoyer la valeur du champ que vous souhaitez mettre à jour. Par exemple, supposons que nous voulions ajouter une date de consentement et la définir à `01/23/2018`.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/users/USER_ID' \
    --header 'authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{"user_metadata":{"consentDate":"01/24/2018"}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/USER_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"user_metadata":{"consentDate":"01/24/2018"}}", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/USER_ID"

  	payload := strings.NewReader("{"user_metadata":{"consentDate":"01/24/2018"}}")

  	req, _ := http.NewRequest("PATCH", url, payload)

  	req.Header.Add("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("content-type", "application/json")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.patch("https://{yourDomain}/api/v2/users/USER_ID")
    .header("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
    .header("content-type", "application/json")
    .body("{"user_metadata":{"consentDate":"01/24/2018"}}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/users/USER_ID',
    headers: {
      authorization: 'Bearer YOUR_MGMT_API_ACCESS_TOKEN',
      'content-type': 'application/json'
    },
    data: {user_metadata: {consentDate: '01/24/2018'}}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/USER_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{"user_metadata":{"consentDate":"01/24/2018"}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{"user_metadata":{"consentDate":"01/24/2018"}}"

  headers = {
      'authorization': "Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      'content-type': "application/json"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/users/USER_ID", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/USER_ID")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Patch.new(url)
  request["authorization"] = 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'
  request["content-type"] = 'application/json'
  request.body = "{"user_metadata":{"consentDate":"01/24/2018"}}"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Cela ajoutera une nouvelle propriété au profil de l’utilisateur, **user\_metadata.consentDate**, qui contiendra la date à laquelle le client a consenti. La réponse sera le profil complet de l’utilisateur. Les métadonnées mises à jour ressembleront à ceci :

```json lines theme={null}
{
  "consentGiven": true,
  "consentDate": "01/23/2018",
  "consentDetails": "some-url"
}
```

<div id="update-inner-property">
  #### Mettre à jour une propriété imbriquée
</div>

Pour mettre à jour une propriété imbriquée, vous devez envoyer l’objet metadata au complet, même si vous ne mettez à jour qu’une seule propriété. Si vous n’incluez pas l’objet en entier, Auth0 supprimera vos propriétés existantes.

Ajoutons une propriété imbriquée pour la date de consentement et définissons-la à `01/23/2018`.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/users/USER_ID' \
    --header 'authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/USER_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/USER_ID"

  	payload := strings.NewReader("{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}")

  	req, _ := http.NewRequest("PATCH", url, payload)

  	req.Header.Add("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("content-type", "application/json")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.patch("https://{yourDomain}/api/v2/users/USER_ID")
    .header("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
    .header("content-type", "application/json")
    .body("{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/users/USER_ID',
    headers: {
      authorization: 'Bearer YOUR_MGMT_API_ACCESS_TOKEN',
      'content-type': 'application/json'
    },
    data: {
      user_metadata: {consent: {given: true, date: '01/23/2018', text_details: 'some-url'}}
    }
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/USER_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}"

  headers = {
      'authorization': "Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      'content-type': "application/json"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/users/USER_ID", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/USER_ID")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Patch.new(url)
  request["authorization"] = 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'
  request["content-type"] = 'application/json'
  request.body = "{"user_metadata":{"consent": {"given":true, "date":"01/23/2018", "text_details":"some-url"}}}"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Cela ajoutera une nouvelle propriété au profil utilisateur, **user\_metadata.consent.date,** qui contiendra la date à laquelle le client a donné son consentement. La réponse sera le profil utilisateur complet. Les métadonnées mises à jour ressembleront à ceci :

```json lines theme={null}
{
  "consent": {
    "given": true,
    "date": "01/23/2018",
    "text_details": "some-url"
  }
}
```

<div id="export-consent-information">
  ### Exporter les renseignements sur le consentement
</div>

Pour exporter une liste de vos utilisateurs à l’aide de la Management API, utilisez le [point de terminaison **User Export**](/docs/fr-ca/manage-users/user-search/user-search-best-practices).

Ce point de terminaison crée une tâche qui exporte tous les utilisateurs associés à une connexion. Vous aurez besoin de l’ID de la connexion. Pour trouver cet ID, utilisez le [point de terminaison **Get Connections**](https://auth0.com/docs/api/management/v2#!/Connections/get_connections) (vous pouvez définir le paramètre **name** sur le nom de la connexion afin de récupérer uniquement celle-ci).

Une fois que vous avez l’ID de la connexion et un jeton d’accès pour la Management API, vous êtes prêt à commencer l’exportation des utilisateurs. Pour voir un exemple de requête et de réponse, consultez [Import and Export Users](/docs/fr-ca/manage-users/user-migration). Pour savoir comment obtenir un jeton d’accès pour la Management API, consultez [Management API Access Tokens](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens).

Vous devez aussi :

* Déterminer comment vous voulez faire le suivi du consentement. Nous recommandons d’inclure non seulement la date à laquelle l’utilisateur a donné son consentement, mais aussi la version des conditions générales qu’il a acceptées. Nous recommandons également d’inclure un tableau pour consigner l’information sur les utilisateurs qui retirent leur consentement (n’oubliez pas que l’utilisateur peut donner et retirer son consentement plusieurs fois).
* Choisir où vous voulez stocker le consentement : dans la base de données d’Auth0 ou ailleurs.

<div id="withdraw-consent">
  ## Retirer le consentement
</div>

L'utilisateur devrait avoir la possibilité de retirer son consentement dans votre application. Cette option devrait être facilement accessible et clairement identifiable. Une fois que l'utilisateur décide de retirer son consentement, vous devriez prendre les mesures nécessaires.

Vous devez d'abord décider comment vous gérerez le retrait du consentement : supprimerez-vous les utilisateurs ou les marquerez-vous comme supprimés ?

<div id="delete-user">
  ### Supprimer un utilisateur
</div>

Pour supprimer un utilisateur, utilisez le point de terminaison [**Supprimer un utilisateur**](https://auth0.com/docs/api/management/v2#!/Users/delete_users_by_id).

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request DELETE \
    --url 'https://{yourDomain}/api/v2/users/USER_ID' \
    --header 'authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/USER_ID");
  var request = new RestRequest(Method.DELETE);
  request.AddHeader("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN");
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/USER_ID"

  	req, _ := http.NewRequest("DELETE", url, nil)

  	req.Header.Add("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.delete("https://{yourDomain}/api/v2/users/USER_ID")
    .header("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'DELETE',
    url: 'https://{yourDomain}/api/v2/users/USER_ID',
    headers: {authorization: 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/USER_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer YOUR_MGMT_API_ACCESS_TOKEN" }

  conn.request("DELETE", "/{yourDomain}/api/v2/users/USER_ID", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/USER_ID")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Delete.new(url)
  request["authorization"] = 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Le corps de la réponse de ce point de terminaison est vide. Donc, si vous voulez confirmer que l’utilisateur a bien été supprimé, essayez de le récupérer à l’aide de son courriel. Si le point de terminaison renvoie une erreur, cela signifie que votre requête de suppression de l’utilisateur a réussi.

<div id="flag-user-as-deleted">
  ### Marquer l’utilisateur comme supprimé
</div>

Si vous ne voulez pas supprimer l’utilisateur, marquez son profil comme supprimé à l’aide du point de terminaison [**app\_metadata**](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id). Ensuite, ajoutez du code pour faire échouer le processus d’authentification pour tout utilisateur dont le profil est marqué comme tel.

Cela vous permet de conserver une trace des utilisateurs supprimés pour usage ultérieur.

<div id="flag-the-profile">
  #### Marquer le profil
</div>

Pour marquer un utilisateur comme supprimé, utilisez `app_metadata`. Dans l’exemple suivant, nous vous montrons comment ajouter une propriété appelée **deleted** au champ **app\_metadata**. Cela vous permet de configurer le processus d’authentification pour traiter comme supprimés tous les utilisateurs dont cette propriété est définie à true.

Pour mettre à jour les métadonnées d’un utilisateur, utilisez le point de terminaison [**Update a User**](https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id).

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/users/USER_ID' \
    --header 'authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{"app_metadata":{"deleted":true}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/USER_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"app_metadata":{"deleted":true}}", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/USER_ID"

  	payload := strings.NewReader("{"app_metadata":{"deleted":true}}")

  	req, _ := http.NewRequest("PATCH", url, payload)

  	req.Header.Add("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("content-type", "application/json")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.patch("https://{yourDomain}/api/v2/users/USER_ID")
    .header("authorization", "Bearer YOUR_MGMT_API_ACCESS_TOKEN")
    .header("content-type", "application/json")
    .body("{"app_metadata":{"deleted":true}}")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/users/USER_ID',
    headers: {
      authorization: 'Bearer YOUR_MGMT_API_ACCESS_TOKEN',
      'content-type': 'application/json'
    },
    data: {app_metadata: {deleted: true}}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/USER_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{"app_metadata":{"deleted":true}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{"app_metadata":{"deleted":true}}"

  headers = {
      'authorization': "Bearer YOUR_MGMT_API_ACCESS_TOKEN",
      'content-type': "application/json"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/users/USER_ID", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/USER_ID")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Patch.new(url)
  request["authorization"] = 'Bearer YOUR_MGMT_API_ACCESS_TOKEN'
  request["content-type"] = 'application/json'
  request.body = "{"app_metadata":{"deleted":true}}"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

<div id="disable-login-for-flagged-users">
  #### Désactiver la connexion pour les utilisateurs marqués
</div>

Ensuite, vous devez désactiver la connexion pour les utilisateurs marqués comme supprimés. Pour ce faire, vous allez ajouter une Rule (un extrait Javascript qui s’exécute dans le pipeline d’authentification).

1. Accédez à [Auth0 Dashboard > Auth Pipeline > Rules](https://manage.auth0.com/#/rules) et créez une Rule.
2. Copiez le script ci-dessous :

   ```javascript lines theme={null}
   function (user, context, callback) {
     user.app_metadata = user.app_metadata || {};
     if (user.app_metadata.deleted){
     	return callback(new UnauthorizedError('Access denied (deleted user)'));
     }
     callback(null, user, context);
   }
   ```

   Le script fait ce qui suit :

   1. Vérifie la valeur de la propriété de métadonnées **deleted** (`user.app_metadata.deleted`).
   2. Renvoie une erreur `Access denied (deleted user)` à votre application si `user.app_metadata.deleted = true`
3. Donnez un nom à votre Rule et enregistrez vos modifications.

Vous devez aussi :

* Veiller à ce que la partie du retrait du consentement soit suffisamment granulaire.
* Configurer dans l’application la section où les clients retireront leur consentement.

<div id="learn-more">
  ## Pour en savoir plus
</div>

* [RGPD : minimisation des données](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-data-minimization)
* [RGPD : portabilité des données](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-data-portability)
* [RGPD : protection et sécurisation des données utilisateur](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-protect-and-secure-user-data)
* [RGPD : droit d’accès, de rectification et d’effacement des données](/docs/fr-ca/secure/data-privacy-and-compliance/gdpr/gdpr-right-to-access-correct-and-erase-data)