> ## 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 controlar el comportamiento de Login con un Proveedor de identidad social o empresarial pasando parámetros de consulta desde su aplicación de Auth0 durante la solicitud de autorización.

# Pasar parámetros a proveedores de identidad

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 pasar parámetros específicos del proveedor a un <Tooltip tip="Proveedor de identidad (IdP): servicio que almacena y gestiona identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=Identity+Provider">Proveedor de identidad</Tooltip> (IdP) durante la autenticación. Los valores pueden ser estáticos para cada conexión o dinámicos para cada usuario.

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

Para esta configuración, tenga en cuenta las siguientes restricciones:

* Solo se aceptan [parámetros válidos de OAuth 2.0/OIDC](http://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint).
* No todos los IdP admiten parámetros upstream. Consulte con el IdP específico antes de continuar con la implementación.
* Los IdP de <Tooltip tip="Security Assertion Markup Language (SAML): Protocolo estandarizado que permite a dos partes intercambiar información de autenticación sin contraseña." cta="Ver glosario" href="/es/docs/glossary?term=SAML">SAML</Tooltip> no admiten parámetros upstream.

<div id="static-parameters">
  ## Parámetros estáticos
</div>

Utilice parámetros estáticos para configurar su conexión de modo que envíe un conjunto estándar de parámetros al IdP cuando un usuario inicie sesión.

Para configurar parámetros estáticos, llame a los endpoints de Auth0 <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip> [Crear una conexión](https://auth0.com/docs/api/management/v2/#!/Connections/post_connections) o [Actualizar una conexión](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id), y pase el objeto `upstream_params` dentro del objeto `options` con los parámetros que desee enviar al IdP.

<div id="example-wordpress">
  ### Ejemplo: WordPress
</div>

WordPress te permite pasar un parámetro `blog` opcional a su endpoint de autorización de <Tooltip tip="OAuth 2.0: marco de autorización que define protocolos y flujos de autorización." cta="Ver glosario" href="/es/docs/glossary?term=OAuth+2.0">OAuth 2.0</Tooltip> y solicitar automáticamente acceso al blog especificado cuando los usuarios inician sesión. Para obtener más información, consulta la [documentación de OAuth 2.0 de WordPress](https://developer.wordpress.com/docs/oauth2/).

Para seguir este ejemplo, necesitarás una [conexión social de WordPress](https://marketplace.auth0.com/integrations/wordpress-social-connection) en funcionamiento.

<div id="get-the-connection">
  #### Obtener la conexión
</div>

Llame al endpoint [Get a connection](https://auth0.com/docs/api/management/v2#!/Connections/get_connections_by_id) de la Management API para obtener los valores actuales del objeto `options`:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID} \
    --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
    --header 'content-type: application/json'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}");
  request.AddHeader("content-type", "application/json");
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}"

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

  	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_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.get("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}")
    .header("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}")
    .header("content-type", "application/json")
    .asString();
  ```

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

  var options = {
    method: 'GET',
    url: 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}',
    headers: {
      authorization: 'Bearer {YOUR_MANAGEMENT_API_TOKEN}',
      'content-type': 'application/json'
    }
  };

  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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}",
    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_MANAGEMENT_API_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("")

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

  conn.request("GET", "/{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_WORDPRESS_CONNECTION_ID}")

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

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer {YOUR_MANAGEMENT_API_TOKEN}'
  request["content-type"] = 'application/json'

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

El objeto `options` tendrá un aspecto similar al siguiente:

```json lines theme={null}
{
  "options": {
    "client_id": "", 
    "profile": true, 
    "scope": ["profile"]
  }
}
```

<div id="update-the-connection-static">
  #### Actualiza la conexión (estática)
</div>

Copia el objeto `options` existente y, a continuación, añade el objeto `upstream_params` con el campo `blog` como atributo:

```json lines theme={null}
{
  "options": {
    "client_id": "", 
    "profile": true, 
    "scope": ["profile"],
    "upstream_params": {
      "blog": {"value":"myblog.wordpress.com"}
    }
  }
}
```

Llama al endpoint [Actualizar una conexión](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de la Management API con el objeto `options` en el cuerpo:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D' \
    --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
    --header 'content-type: application/json' \
    --data '{"options":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"options":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D"

  	payload := strings.NewReader("{"options":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}")

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

  	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D")
    .header("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}")
    .header("content-type", "application/json")
    .body("{"options":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D',
    headers: {
      authorization: 'Bearer {YOUR_MANAGEMENT_API_TOKEN}',
      'content-type': 'application/json'
    },
    data: {
      options: {
        client_id: '',
        profile: true,
        scope: ['profile'],
        upstream_params: {blog: {value: 'myblog.wordpress.com'}}
      }
    }
  };

  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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D",
    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":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {YOUR_MANAGEMENT_API_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":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}"

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

  conn.request("PATCH", "/{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D", 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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/%7ByourWordpressConnectionId%7D")

  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_MANAGEMENT_API_TOKEN}'
  request["content-type"] = 'application/json'
  request.body = "{"options":{"client_id":"","profile":true,"scope":["profile"],"upstream_params":{"blog":{"value":"myblog.wordpress.com"}}}}"

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

Ahora, cada vez que un usuario se autentique con esta conexión, la solicitud al endpoint de autorización de WordPress incluirá el parámetro de consulta `blog=myblog.wordpress.com`.

<div id="dynamic-parameters">
  ## Parámetros dinámicos
</div>

Use parámetros dinámicos para configurar su conexión de modo que envíe al IdP un conjunto de parámetros con valores específicos del usuario cuando inicie sesión.

Para configurar parámetros dinámicos, llame al endpoint [Create a connection](https://auth0.com/docs/api/management/v2/#!/Connections/post_connections) o [Update a connection](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de la Management API de Auth0, pase el objeto `upstream_params` dentro del objeto `options` con los parámetros que desea enviar al IdP y especifique el campo con el que se asigna el parámetro mediante el atributo `alias`.

A continuación, se muestra un ejemplo del objeto `options` que retomaremos más adelante en el ejemplo X:

```json lines theme={null}
{
  "options": {
    "upstream_params": {
      "screen_name": {
        "alias": "login_hint"
      }
    }
  }
}
```

<div id="available-fields">
  ### Campos disponibles
</div>

Estos son los campos disponibles del atributo `alias`:

* `acr_values`
* `audience`
* `client_id`
* `display`
* `id_token_hint`
* `login_hint`
* `max_age`
* `prompt`
* `resource`
* `response_mode`
* `response_type`
* `ui_locales`

<div id="example-x">
  ### Ejemplo: X
</div>

X le permite pasar un parámetro opcional `screen_name` a su endpoint de autorización OAuth. El parámetro `screen_name` rellena previamente el campo de username de la pantalla de inicio de sesión con el valor indicado. Para obtener más información, consulte [la referencia de la API de X](https://docs.x.com/fundamentals/authentication/api-reference#get-oauth%2Fauthorize).

Para seguir este ejemplo, necesitará una [conexión social de X](https://marketplace.auth0.com/integrations/twitter-social-connection) en funcionamiento.

#### Obtener la Conexión

Llame al endpoint [Get a connection](https://auth0.com/docs/api/management/v2#!/Connections/get_connections_by_id) de Management API para recuperar los valores actuales del objeto `options`:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}' \
    --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
    --header 'content-type: application/json'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}");
  request.AddHeader("content-type", "application/json");
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}"

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

  	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_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.get("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}")
    .header("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}")
    .header("content-type", "application/json")
    .asString();
  ```

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

  var options = {
    method: 'GET',
    url: 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}',
    headers: {
      authorization: 'Bearer {YOUR_MANAGEMENT_API_TOKEN}',
      'content-type': 'application/json'
    }
  };

  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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}",
    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_MANAGEMENT_API_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("")

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

  conn.request("GET", "/{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}")

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

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer {YOUR_MANAGEMENT_API_TOKEN}'
  request["content-type"] = 'application/json'

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

El objeto `options` tendrá un aspecto similar al siguiente:

```text lines theme={null}
"options": {
  "client_id": "YOUR_CLIENT_ID",
  "client_secret": "YOUR_CLIENT_SECRET",
  "profile": true
}
```

<div id="update-the-connection-dynamic">
  #### Actualizar la conexión (dinámica)
</div>

Copie el objeto `options` existente, agregue el objeto `upstream_params` con el campo `screen_name` como atributo y, a continuación, configure el atributo `alias` como `login_hint`:

```json lines theme={null}
{
  "options": {
    "client_id": "", 
    "profile": true, 
    "scope": ["profile"],
    "upstream_params": {
      "screen_name": {
        "alias": "login_hint"
      }
    }
  }
}
```

Llame al endpoint [Actualizar una conexión](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de Management API con el objeto `options` en el cuerpo:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}' \
    --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
    --header 'content-type: application/json' \
    --data '{"options": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}");
  request.AddHeader("content-type", "application/json");
  request.AddParameter("application/json", "{"options": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}"

  	payload := strings.NewReader("{"options": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}")

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

  	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}")
    .header("authorization", "Bearer {YOUR_MANAGEMENT_API_TOKEN}")
    .header("content-type", "application/json")
    .body("{"options": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_CONNECTION_ID}',
    headers: {
      authorization: 'Bearer {YOUR_MANAGEMENT_API_TOKEN}',
      'content-type': 'application/json'
    },
    data: {
      options: {
        client_id: '{YOUR_CLIENT_ID}',
        client_secret: '{YOUR_CLIENT_SECRET}',
        profile: true,
        upstream_params: {screen_name: {alias: 'login_hint'}}
      }
    }
  };

  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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_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": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer {YOUR_MANAGEMENT_API_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": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}"

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

  conn.request("PATCH", "/{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_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://{YOUR_AUTH0_DOMAIN}/api/v2/connections/{YOUR_X_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_MANAGEMENT_API_TOKEN}'
  request["content-type"] = 'application/json'
  request.body = "{"options": {"client_id": "{YOUR_CLIENT_ID}", "client_secret": "{YOUR_CLIENT_SECRET}", "profile": true, "upstream_params": {"screen_name": {"alias": "login_hint"}}}}"

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

<div id="call-the-login-endpoint">
  #### Llama al endpoint de inicio de sesión
</div>

Cuando llames al [endpoint de inicio de sesión](https://auth0.com/docs/api/authentication#login) de la API de autenticación para un usuario, puedes pasar su correo electrónico al parámetro `login_hint`:

export const codeExample41 = `https://{YOUR_AUTH0_DOMAIN}/authorize
  ?client_id={YOUR_CLIENT_ID}
  &response_type=token
  &redirect_uri={https://yourApp/callback}
  &scope=openid%20name%20email
  &login_hint=user@domain.com`;

<AuthCodeBlock children={codeExample41} language="bash" />

A continuación, este valor se pasará al endpoint de autorización de X como parámetro `screen_name`:

```text lines theme={null}
https://api.x.com/oauth/authorize
  ?oauth_token={yourXAuthToken}
  &screen_name=user@domain.com
```