> ## 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 définir le comportement de l’organisation dans les applications avec la fonctionnalité Organizations d’Auth0.

# Définir le comportement de l’organisation

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

Lorsque vous représentez votre application dans Auth0, vous pouvez préciser quels types d’utilisateurs elle doit prendre en charge. Certaines applications permettent à des utilisateurs individuels de se connecter avec des comptes personnels, tandis que d’autres sont destinées aux membres d’[organizations](/docs/fr-ca/manage-users/organizations/organizations-overview). Certaines doivent prendre en charge les deux. C’est ce qu’on appelle le comportement d’organisation, et il peut être défini pour chaque application que vous connectez à Auth0.

Par exemple, votre application pourrait avoir :

* Une page d’accueil marketing générique avec un bouton **Se connecter** qui dirige vos utilisateurs vers le login flow d’Auth0 sans organisation.
* Une URL distincte pour chacun de vos clients B2B (par ex., les utilisateurs d’Acme vont à `acme.yourcompany.com`) qui redirige les utilisateurs vers Auth0 avec une organisation, afin qu’ils voient le bouton <Tooltip tip="Single Sign-On (SSO) : service qui, après qu’un utilisateur s’est connecté à une application, le connecte automatiquement à d’autres applications." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SSO">SSO</Tooltip> Login d’Acme.

Vous pouvez définir le comportement d’organisation pour permettre l’un ou l’autre de ces scénarios. De plus, vous pouvez configurer le comportement d’organisation de sorte que, si votre application exige qu’une organisation soit fournie, mais que votre utilisateur est envoyé par erreur à Auth0 sans organisation, il verra une invite lui permettant d’entrer le nom de son organisation.

Vous pouvez définir le comportement d’organisation au moyen soit du <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=Auth0+Dashboard">Auth0 Dashboard</Tooltip>, soit de la <Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip>.

<div id="auth0-dashboard">
  ## Auth0 Dashboard
</div>

Pour définir le comportement d’une organisation dans l’Auth0 Dashboard :

1. Accédez à [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications), puis sélectionnez l’application pour laquelle vous souhaitez configurer les organisations.
2. Passez à la vue Expérience de connexion et configurez les paramètres appropriés :

| Champ                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | mappage API                                                                                                                                                                                                                                                                                      |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Type d’utilisateurs**          | Détermine quelle catégorie d’utilisateurs peut se connecter à votre application.<br /><br />Les options comprennent : <ul> <li> **Particuliers** : Les utilisateurs peuvent s’inscrire avec un compte personnel et se connecter directement à votre application. Les utilisateurs individuels ne peuvent pas se connecter à l’aide d’une organisation. </li> <li> **Business Users** : Les utilisateurs doivent être membres d’une organisation pour se connecter. Lorsque cette option est sélectionnée, vous devez soit fournir une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize`, soit définir votre Flux de connexion sur Prompt for organisation. </li> <li> **Both** : Les utilisateurs peuvent se connecter comme membres d’une organisation ou s’inscrire avec un compte personnel. </li> </ul>                | **Type d’utilisateurs** correspond à `organization_usage`<br /><br />Options : <ul> <li>**Particuliers** correspond à `deny`</li> <li>**Business Users** correspond à `require`</li> <li>**Both** correspond à `allow`</li> </ul>                                                                |
| **Flux de connexion**            | Détermine l’invite de connexion initiale présentée aux utilisateurs lorsqu’ils accèdent à votre application. Vous ne pouvez configurer ce champ que si le type d’utilisateurs est défini sur Business Users ou Both.<br /><br />Les options comprennent : <ul> <li> **Prompt for Credentials** : Les utilisateurs doivent d’abord saisir leurs identifiants de connexion. Après s’être connectés, ils peuvent sélectionner leur organisation. </li> <li> **Prompt for organisation** : Les utilisateurs doivent d’abord sélectionner leur organisation. Ils peuvent ensuite fournir leurs identifiants pour se connecter. </li> <li> **Aucune invite** : Auth0 ne détermine pas quelle invite de connexion est présentée aux utilisateurs. C’est plutôt votre application qui doit envoyer à Auth0 les paramètres requis pour afficher l’invite appropriée. </li> </ul> | **Flux de connexion** correspond à `organization_require_behavior`<br /><br />Options : <ul> <li>**Prompt for Credentials** correspond à `post_login_prompt`</li> <li>**Prompt for organisation** correspond à `pre_login_prompt`</li> <li>**Aucune invite** correspond à `no_prompt`</li> </ul> |
| **Découverte de l’organisation** | Définit la méthode utilisée pour identifier l’organisation de l’utilisateur avant l’authentification. Disponible uniquement avec le Flux de connexion Prompt for organisation.<br /><br />Les options comprennent : <ul> <li> **Prompt for organisation Email** : Les utilisateurs doivent d’abord fournir l’adresse courriel associée à leur organisation. </li> <li> **Prompt for organisation Name** : Les utilisateurs doivent d’abord fournir le nom de leur organisation. </li> <li> **Prompt for organisation Email and Name** : Les utilisateurs doivent d’abord fournir le nom de leur organisation ou l’adresse courriel qui y est associée. </li> </ul>                                                                                                                                                                                                      | <ul> <li> **Prompt for Emails** : correspond à `email`. </li> <li> **Prompt for organisation** : correspond à `organization_name`. </li> <li> **Prompt for organisation Email and Name** : correspond à `email` et `organization_name`. </li> </ul>                                              |

3. Sélectionnez **Save changes**.

<div id="management-api">
  ## Management API
</div>

Effectuez une requête `PATCH` vers le [point de terminaison Update a Client](https://auth0.com/docs/api/management/v2#!/Clients/patch_clients_by_id). Assurez-vous de remplacer les valeurs de l’espace réservé `client_id`, `mgmt_api_access_token`, `organization_usage` et `organization_require_behavior` par votre <Tooltip tip="ID client : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Consulter le glossaire" href="/docs/fr-ca/glossary?term=client+ID">ID client</Tooltip>, le jeton d’accès de la Management API <Tooltip tip="ID client : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Consulter le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip>, l’option d’utilisation de l’organisation et l’option de comportement de l’organisation, respectivement.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/clients/CLIENT_ID' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/clients/CLIENT_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", "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }", 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/clients/CLIENT_ID"

  	payload := strings.NewReader("{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }")

  	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/clients/CLIENT_ID")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/clients/CLIENT_ID',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {
      organization_usage: 'ORG_USAGE',
      organization_require_behavior: 'ORG_REQUIRE_BEHAVIOR'
    }
  };

  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/clients/CLIENT_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 => "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }",
    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 = "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }"

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

  conn.request("PATCH", "/{yourDomain}/api/v2/clients/CLIENT_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/clients/CLIENT_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["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "organization_usage": "ORG_USAGE", "organization_require_behavior": "ORG_REQUIRE_BEHAVIOR" }"

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

| Valeur                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CLIENT_ID`                      | ID de l’application pour laquelle vous voulez ajouter un comportement d’organisation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `MGMT_API_ACCESS_TOKEN`          | [Jetons d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la portée `update:clients`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `ORGANIZATION_USAGE`             | Indique si votre application peut prendre en charge des utilisateurs qui se connectent à une organisation. Les options comprennent : <ul> <li>`deny` : (par défaut) Les utilisateurs ne peuvent pas se connecter au moyen d’une organisation.</li> <li>`allow` : Les utilisateurs peuvent se connecter avec ou sans organisation. Lorsque cette option est sélectionnée, vous devez fournir une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize`.</li> <li>`require` : Les utilisateurs doivent se connecter au moyen d’une organisation. Lorsque cette option est sélectionnée, vous devez soit fournir une organisation lorsque vous redirigez les utilisateurs vers le point de terminaison `/authorize`, soit définir `organization_require_behavior` sur `pre_login_prompt` pour permettre aux utilisateurs de choisir une organisation avant de se connecter.</li> </ul> |
| `ORGANIZATION_REQUIRE_BEHAVIOR`  | Détermine le flux de connexion présenté aux utilisateurs qui accèdent à votre application. S’applique uniquement lorsque `organization_usage` est défini sur `require` ou `allow`.<br /><br />Les options comprennent : <ul> <li>`no_prompt` : (par défaut) N’affiche aucune invite. Les requêtes sans paramètre d’organisation valide sont rejetées.</li> <li>`pre_login_prompt` : Invite les utilisateurs à sélectionner une organisation avant de pouvoir se connecter. Vous ne pouvez utiliser cette option que si `organization_usage` est défini sur `require`.</li> <li>`post_login_prompt` : Invite les utilisateurs à se connecter avec leurs informations d’identification. Après la connexion, invite les utilisateurs à sélectionner leur organisation.</li> </ul>                                                                                                                                               |
| `ORGANIZATION_DISCOVERY_METHODS` | Détermine la méthode permettant d’identifier l’organisation d’un utilisateur avant l’authentification. S’applique uniquement lorsque `organization_require_behavior` correspond à `pre_login_prompt` et que `organization_usage` est défini sur `require` ou `allow`. <ul> <li> `email` : (par défaut) Les utilisateurs sont invités à saisir leur adresse courriel associée à leur organisation. </li> <li> `organization_name` : Les utilisateurs sont invités à saisir le nom associé à leur organisation. </li> <li> `Organization name` et `email` : Les utilisateurs sont invités à saisir l’adresse courriel ou le nom associé à leur organisation. </li> </ul>                                                                                                                                                                                                                                                       |

<div id="response-status-codes">
  ### Codes d’état de réponse
</div>

Les codes d’état de réponse possibles sont les suivants :

| Code d’état | Code d’erreur             | Message                                                                                                                                                        | Cause                                                                                                |
| ----------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `200`       |                           | Client mis à jour avec succès.                                                                                                                                 |                                                                                                      |
| `400`       | `invalid_uri`             | URI de requête invalide. Le message varie en fonction de la cause.                                                                                             | Le chemin n’est pas valide.                                                                          |
| `400`       | `invalid_body`            | Corps de la requête invalide. Le message varie en fonction de la cause.                                                                                        | La charge utile de la requête n’est pas valide.                                                      |
| `401`       |                           | Jeton invalide.                                                                                                                                                |                                                                                                      |
| `401`       |                           | Le client n’est pas global.                                                                                                                                    |                                                                                                      |
| `401`       |                           | Signature invalide reçue lors de la validation du JSON Web Token.                                                                                              |                                                                                                      |
| `403`       | `insufficient_scope`      | Scope insuffisant; l’un des suivants est attendu : `update:clients`.                                                                                           | Tentative de lecture ou d’écriture d’un champ non autorisée avec les scopes du bearer token fournis. |
| `403`       | `insufficient_scope`      | Certains champs ne peuvent pas être mis à jour avec les permissions accordées par les scopes du bearer token. Le message varie selon les champs et les scopes. | Tentative de lecture ou d’écriture d’un champ non autorisée avec les scopes du bearer token fournis. |
| `403`       | `operation_not_supported` | Le compte n’est pas autorisé à effectuer cette opération.                                                                                                      | Le compte n’est pas autorisé à effectuer cette opération.                                            |
| `404`       | `inexistent_client`       | Client introuvable.                                                                                                                                            | Ressource inexistante. L’application spécifiée n’existe pas.                                         |
| `429`       |                           | Trop de requêtes. Vérifiez les en-têtes X-RateLimit-Limit, X-RateLimit-Remaining et X-RateLimit-Reset.                                                         |                                                                                                      |