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

> Aprenda a actualizar las preferencias de conexión de un proveedor de identidad ascendente para controlar cuándo se actualizan los atributos raíz del perfil de usuario.

# Configurar la conexión del Proveedor de identidad para las actualizaciones del perfil de usuario

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

Puede actualizar las preferencias de la conexión de un <Tooltip tip="Proveedor de identidad (IdP): servicio que almacena y administra identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=identity+provider">proveedor de identidad</Tooltip> ascendente para controlar cuándo se permiten las actualizaciones de los atributos raíz del perfil de usuario mediante el <Tooltip tip="Proveedor de identidad (IdP): servicio que almacena y administra identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> o la <Tooltip tip="Auth0 Dashboard: el producto principal de Auth0 para configurar sus servicios." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip>.

De forma predeterminada, los atributos del perfil de usuario proporcionados por proveedores de identidad distintos de Auth0 (como Google, Facebook o X) no se pueden editar directamente porque se actualizan desde el proveedor de identidad cada vez que el usuario inicia sesión.

Para poder editar los atributos raíz name, nickname, given\_name, family\_name o picture en el perfil de usuario normalizado, debe configurar la sincronización de su conexión con Auth0 para que los atributos del usuario se actualicen desde el proveedor de identidad solo cuando se crea el perfil de usuario.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  **Sincronizar usuarios al iniciar sesión** no se aplica a las conexiones sin contraseña y no se puede habilitar mediante la interfaz de usuario del Tenant ni la Management API.
</Callout>

Puede editar los [atributos raíz individualmente](/es/docs/manage-users/user-accounts/user-profiles/root-attributes/update-root-attributes-for-users) o mediante una [importación masiva](/es/docs/manage-users/user-accounts/user-profiles/root-attributes/set-root-attributes-during-user-import) con la Management API.

<div id="use-the-dashboard">
  ## Usa el Dashboard
</div>

1. Ve a [Auth0 Dashboard > Autenticación](https://manage.auth0.com/#/connections) y selecciona el tipo de conexión: Base de datos, Social, Empresarial o sin contraseña.
2. Selecciona el nombre de una conexión para ver su configuración.
3. Busca la sección **Avanzado**, ajusta el interruptor **Sincronizar atributos del perfil de usuario al iniciar sesión** según la configuración deseada y selecciona **Guardar**.

<div id="use-the-management-api">
  ## Usa la Management API
</div>

Antes de completar este paso, primero debes [recuperar los valores existentes del objeto `options` de la conexión](/es/docs/authenticate/identity-providers/retrieve-connection-options) para evitar sobrescribir los valores actuales. Si no lo haces, los parámetros que falten en el objeto original se perderán después de la actualización.

Haz una llamada `PATCH` al [endpoint Update a Connection](https://auth0.com/docs/api/management/v2#!/Connections/patch_connections_by_id). Asegúrate de incluir en la llamada los valores originales de `options` para evitar sobrescribir los valores actuales. Además, asegúrate de reemplazar los valores de marcador de posición `CONNECTION_ID`, `MGMT_API_ACCESS_TOKEN` y `ATTRIBUTE_UPDATE_VALUE` por el ID de tu conexión, el <Tooltip tip="Token de acceso: credencial de autorización, en forma de una cadena opaca o un JWT, que se utiliza para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=access+token">token de acceso</Tooltip> de la Management API y el valor de actualización del atributo, respectivamente.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/connections/CONNECTION_ID' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{"options":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections/CONNECTION_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{"options":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}", 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/CONNECTION_ID"

  	payload := strings.NewReader("{"options":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}")

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

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	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/CONNECTION_ID")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{"options":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/connections/CONNECTION_ID',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {options: {set_user_root_attributes: 'ATTRIBUTE_UPDATE_VALUE'}}
  };

  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/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":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "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":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/connections/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/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["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{"options":{"set_user_root_attributes": "ATTRIBUTE_UPDATE_VALUE"}}"

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

| Valor                    | Descripción                                                                                                                                                                                                                   |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CONNECTION_ID`          | ID de la conexión para la que quiere permitir actualizaciones de atributos raíz.                                                                                                                                              |
| `MGMT_API_ACCESS_TOKEN`  | [Token de acceso para la Management API](https://auth0.com/docs/api/management/v2/tokens) con el scope `update:connections`.                                                                                                  |
| `ATTRIBUTE_UPDATE_VALUE` | Indica cuándo quiere permitir actualizaciones de los atributos raíz del perfil de usuario. Los valores válidos son `on_first_login` y `on_each_login`. El valor predeterminado para las conexiones nuevas es `on_each_login`. |

<div id="learn-more">
  ## Más información
</div>

* [Recuperar las opciones de la conexión](/es/docs/authenticate/identity-providers/retrieve-connection-options)
* [Establecer atributos raíz durante la importación de usuarios](/es/docs/manage-users/user-accounts/user-profiles/root-attributes/set-root-attributes-during-user-import)
* [Establecer atributos raíz durante el registro de usuarios](/es/docs/manage-users/user-accounts/user-profiles/root-attributes/set-root-attributes-during-user-sign-up)
* [Actualizar los atributos raíz de los usuarios](/es/docs/manage-users/user-accounts/user-profiles/root-attributes/update-root-attributes-for-users)
* [Promover conexiones a nivel de dominio](/es/docs/authenticate/identity-providers/promote-connections-to-domain-level)