> ## 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écouvrez comment contrôler le comportement de connexion avec un fournisseur d’identité social ou un fournisseur d’identité d’entreprise en transmettant des paramètres de requête depuis votre application Auth0 lors de la requête d’autorisation.

# Transmettre des paramètres aux fournisseurs d’identité

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>;
};

Vous pouvez transmettre à un <Tooltip tip="Fournisseur d’identité (IdP) : service qui stocke et gère les identités numériques." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> (IdP) des paramètres spécifiques au fournisseur pendant l’authentification. Les valeurs peuvent être statiques pour une connexion donnée ou dynamiques pour chaque utilisateur.

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

Pour cette configuration, gardez à l’esprit les restrictions suivantes :

* Seuls les [paramètres OAuth 2.0/OIDC valides](http://openid.net/specs/openid-connect-core-1_0.html#AuthorizationEndpoint) sont acceptés.
* Les IdPs ne prennent pas tous en charge les paramètres en amont. Vérifiez auprès de l’IdP concerné avant de poursuivre votre mise en œuvre.
* Les <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SAML">SAML</Tooltip> IdPs ne prennent pas en charge les paramètres en amont.

<div id="static-parameters">
  ## Paramètres statiques
</div>

Utilisez des paramètres statiques pour configurer votre connexion afin d’envoyer un ensemble standard de paramètres à l’IdP lorsqu’un utilisateur se connecte.

Pour configurer des paramètres statiques, appelez le point de terminaison <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Consulter le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> [Créer une connexion](https://auth0.com/docs/api/management/v2/#!/Connections/post_connections) ou [Mettre à jour une connexion](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id), puis transmettez l’objet `upstream_params` dans l’objet `options` avec les paramètres que vous souhaitez envoyer à l’IdP.

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

WordPress vous permet de transmettre un paramètre facultatif `blog` à son <Tooltip tip="OAuth 2.0 : cadre d’autorisation qui définit les protocoles et les flux d’autorisation." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OAuth+2.0">OAuth 2.0</Tooltip> point de terminaison d’autorisation et de demander automatiquement l’accès à un blogue précis pour les utilisateurs lorsqu’ils se connectent. Pour en savoir plus, consultez [la documentation OAuth 2.0 de WordPress](https://developer.wordpress.com/docs/oauth2/).

Pour suivre cet exemple, vous aurez besoin d’une [connexion sociale WordPress](https://marketplace.auth0.com/integrations/wordpress-social-connection) fonctionnelle.

<div id="get-the-connection">
  #### Récupérer la connexion
</div>

Envoyez une requête au point de terminaison [Get a connection](https://auth0.com/docs/api/management/v2#!/Connections/get_connections_by_id) de la Management API pour récupérer les valeurs existantes de l’objet `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_PEER

  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>

L’objet `options` ressemblera à ceci :

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

<div id="update-the-connection-static">
  #### Mettre à jour la connexion (statique)
</div>

Copiez l’objet `options` existant, puis ajoutez l’objet `upstream_params` en utilisant le champ `blog` comme attribut :

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

Appelez le point de terminaison [mettre à jour une connexion](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de la Management API avec l’objet `options` dans le corps de la requête :

<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_PEER

  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>

Désormais, chaque fois qu’un utilisateur s’authentifie avec cette connexion, la requête envoyée au point de terminaison d’autorisation de WordPress inclura le paramètre de requête `blog=myblog.wordpress.com`.

<div id="dynamic-parameters">
  ## Paramètres dynamiques
</div>

Utilisez des paramètres dynamiques pour configurer votre connexion afin d’envoyer à l’IdP un ensemble de paramètres contenant des valeurs propres à l’utilisateur lorsqu’il se connecte.

Pour configurer des paramètres dynamiques, appelez le endpoint [Create a connection](https://auth0.com/docs/api/management/v2/#!/Connections/post_connections) ou [mettre à jour une connexion](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de l’Auth0 Management API, transmettez l’objet `upstream_params` dans l’objet `options` avec les paramètres que vous souhaitez envoyer à l’IdP, puis indiquez le champ auquel le paramètre est mappé à l’aide de l’attribut `alias`.

Voici un exemple d’objet `options` que nous reprendrons plus loin dans l’exemple X :

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

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

Voici les champs offerts pour l’attribut `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">
  ### Exemple : X
</div>

X vous permet de transmettre un paramètre facultatif `screen_name` à son point de terminaison d’autorisation OAuth. Le paramètre `screen_name` préremplit le champ de saisie du nom d’utilisateur sur l’écran de connexion avec la valeur fournie. Pour en savoir plus, consultez [la référence de l’API de X](https://docs.x.com/fundamentals/authentication/api-reference#get-oauth%2Fauthorize).

Pour suivre cet exemple, vous aurez besoin d’une [connexion sociale X opérationnelle](https://marketplace.auth0.com/integrations/twitter-social-connection).

<div id="get-the-connection">
  #### Récupérer la connexion
</div>

Appelez le point de terminaison [Get a connection](https://auth0.com/docs/api/management/v2#!/Connections/get_connections_by_id) de la Management API pour récupérer les valeurs actuelles de l’objet `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_PEER

  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>

L’objet `options` ressemblera à ceci :

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

<div id="update-the-connection-dynamic">
  #### Mettre à jour la connexion (dynamique)
</div>

Copiez l’objet `options` existant, ajoutez l’objet `upstream_params` avec le champ `screen_name` comme attribut, puis définissez l’attribut `alias` à `login_hint` :

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

Envoyez une requête au point de terminaison [Mettre à jour une connexion](https://auth0.com/docs/api/management/v2/#!/Connections/patch_connections_by_id) de la Management API en incluant l’objet `options` dans le corps :

<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_PEER

  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">
  #### Appeler le point de terminaison de connexion
</div>

Lorsque vous effectuez une requête au [point de terminaison de connexion](https://auth0.com/docs/api/authentication#login) de l’Authentication API pour un utilisateur, vous pouvez transmettre son adresse courriel dans le paramètre `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" />

Cette valeur sera ensuite transmise au point de terminaison d’autorisation de X en tant que paramètre `screen_name` :

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