> ## 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 comment identifier les attributs utilisateur que vous ne souhaitez pas enregistrer dans les bases de données d’Auth0.

# Ajouter des attributs utilisateur à la liste de refus

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) + "*****MASKED*****";
          }
          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>;
};

S’il existe des champs utilisateur qui ne devraient pas être stockés dans les bases de données Auth0 pour des raisons de confidentialité, vous pouvez les ajouter à la liste de refus. Pour ajouter des attributs à la liste de refus, envoyez une requête `PATCH` au point de terminaison Update Connection de l’<Tooltip tip="Management API : un produit permettant aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip>.

1. Obtenez un jeton d’accès valide pour accéder au point de terminaison [`/patch_connections_by_id`](https://auth0.com/docs/api/management/v2#!/Connections/patch_connections_by_id). Le jeton doit inclure le scope `update:connections`. Consultez [Management API Access Tokens](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens) pour en savoir plus.
2. À l’aide du jeton d’accès et de la liste des attributs à exclure, appelez l’API. Voici un exemple de requête HTTP qui exclut deux attributs : l’origine ethnique et le genre. Gardez à l’esprit que vous devez récupérer l’objet options et envoyer l’objet complet dans votre requête PATCH, car il n’y a pas de "fusion" lorsque vous mettez à jour seulement une ou deux valeurs.

<AuthCodeGroup>
  ```bash cURL theme={null}
      curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/connections/YOUR_CONNECTION_ID' \
    --header 'authorization: Bearer YOUR_TOKEN' \
    --header 'content-type: application/json' \
    --data '{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}'

  ```

  ```csharp C# theme={null}
      var client = new RestClient("https://{yourDomain}/api/v2/connections/YOUR_CONNECTION_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer YOUR_TOKEN");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}", 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/connections/YOUR_CONNECTION_ID"

    payload := strings.NewReader("{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}")

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

    req.Header.Add("authorization", "Bearer YOUR_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<String> response = Unirest.patch("https://{yourDomain}/api/v2/connections/YOUR_CONNECTION_ID")
    .header("authorization", "Bearer YOUR_TOKEN")
    .header("content-type", "application/json")
    .body("{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}")
    .asString();

  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/connections/YOUR_CONNECTION_ID',
    headers: {authorization: 'Bearer YOUR_TOKEN', 'content-type': 'application/json'},
    data: {options: {non_persistent_attrs: ['ethnicity', 'gender']}}
  };

  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/connections/YOUR_CONNECTION_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 => "{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer YOUR_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 = "{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}"

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

  conn.request("PATCH", "/{yourDomain}/api/v2/connections/YOUR_CONNECTION_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/connections/YOUR_CONNECTION_ID")

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

  request = Net::HTTP::Patch.new(url)
  request["authorization"] = 'Bearer YOUR_TOKEN'
  request["content-type"] = 'application/json'
  request.body = "{"options": {"non_persistent_attrs": ["ethnicity", "gender"]}}"

  response = http.request(request)
  puts response.read_body

  ```
</AuthCodeGroup>

Où :

1. `{yourConnectionId}` est l’[ID de la connexion](/fr-CA/docs/authenticate/identity-providers/locate-the-connection-id) pour laquelle ces attributs seront refusés.
   2\. `{yourToken}` est le jeton d’accès que vous avez reçu à l’étape précédente.
   3\. L’objet `options.non_persistent_attrs` contient un tableau des attributs qui seront refusés. Si la revendication que vous souhaitez refuser est envoyée par un fournisseur d’identité (IdP) en amont, vous devez la définir exactement telle qu’elle est envoyée par cet IdP. Par exemple, pour une revendication reçue sous la forme `https://acme.com/temporary_idtoken`, l’objet `non_persistent_attrs` de l’exemple ci-dessus serait :

   ```json wrap lines theme={null}
   {"non_persistent_attrs": ["ethnicity", "gender", "https://acme.com/temporary_idtoken"]}
   ```

<div id="limitations">
  ## Limites
</div>

* Seuls les [champs de premier niveau](/fr-CA/docs/manage-users/user-accounts/user-profiles/user-profile-structure) (comme `user.name` ou `user.phone_number`) peuvent être ajoutés à la liste de refus.

  * Si `user.name` ou `user.nickname` sont refusés, ils ne seront pas inclus dans les jetons.
  * Si `user.email` est refusé, la valeur ne peut pas être associée à une revendication personnalisée. Par exemple, dans une Rule, `context.idToken[namespace + 'work_email'] = user.email` ne fonctionnerait pas.
* Lorsque vous refusez des attributs, ils restent accessibles par les Rules et dans les jetons sortants. Toutefois, si l’un des cas suivants s’applique, les attributs de la liste de refus ne seront **pas** inclus dans les jetons :

  * Vous avez activé l’authentification multifacteur (MFA)
  * Vous avez effectué une redirection au moyen de Rules
  * Votre application utilise la délégation (et vous n’avez pas défini `scope = passthrough`)
  * Votre application utilise l’usurpation d’identité
  * Vous avez activé le paramètre **Use Auth0 instead of the IdP to do Single Sign-On** (locataires hérités seulement)
* Pour les connexions SAMLP, si vous activez le mode Debug, vos journaux contiendront des renseignements sur les attributs de la liste de refus

Si l’une de ces limites est inacceptable, vous pouvez écrire une [Rule](/fr-CA/docs/customize/rules) pour chiffrer les données et les conserver dans l’objet `user.app_metadata`.

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

* [Révoquer l’accès aux API à l’aide des autorisations d’application](/fr-CA/docs/get-started/applications/revoke-api-access)
* [Adresses IP d’Auth0 à ajouter aux listes d’autorisation](/fr-CA/docs/secure/security-guidance/data-security/allowlist)