> ## 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 créer des Organizations à l’aide de l’Auth0 Dashboard et de la Management API.

# Créer des Organizations

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 créer des [organizations](/docs/fr-ca/manage-users/organizations/organizations-overview) à l’aide de l’<Tooltip tip="Auth0 Dashboard : le principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> ou de l’<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>.

<Card title="La disponibilité varie selon le forfait Auth0">
  La disponibilité de cette fonctionnalité dépend de votre forfait Auth0 ou de votre entente personnalisée. Pour en savoir plus, consultez [Tarification](https://auth0.com/pricing).
</Card>

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

Pour créer une organisation dans Auth0 Dashboard :

1. Accédez à [Auth0 Dashboard > Organizations](https://manage.auth0.com/#/organizations).
2. Sélectionnez **Créer une organisation**.
3. Saisissez les renseignements de base de votre organisation, puis sélectionnez **Ajouter une organisation** :

   | **Champ**           | **Description**                                                                                                                                                                                                                                                                                                                                                                                                            |
   | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
   | **Nom**             | Nom de l’organisation que vous souhaitez créer. Il s’agit du nom qu’un utilisateur final saisirait dans l’invite de préconnexion pour indiquer l’organisation par laquelle il souhaite se connecter. Identifiant logique unique. Peut contenir des lettres minuscules, des chiffres, des traits de soulignement (`_`) et des traits d’union (`-`). Peut commencer par un chiffre. Doit comporter entre 1 et 50 caractères. |
   | **Nom d’affichage** | Nom convivial à afficher.                                                                                                                                                                                                                                                                                                                                                                                                  |
4. Repérez la section **Image de marque** et personnalisez votre organisation, puis sélectionnez **Enregistrer les modifications** :

   | **Champ**                             | **Description**                                                                                           |
   | ------------------------------------- | --------------------------------------------------------------------------------------------------------- |
   | **Logo de l’organisation**            | Logo à afficher. La résolution minimale recommandée est de 200 pixels (largeur) sur 200 pixels (hauteur). |
   | **Couleur principale**                | Couleur des éléments principaux.                                                                          |
   | **Couleur d’arrière-plan de la page** | Couleur de l’arrière-plan.                                                                                |
5. Repérez la section **Métadonnées** et ajoutez à l’organisation toutes les paires clé-valeur de métadonnées nécessaires, puis sélectionnez **Ajouter**.

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

Pour créer une organisation à l’aide de la Management API :

Faites une requête `POST` au point de terminaison `Create Organizations`. Assurez-vous de remplacer les valeurs de l’espace réservé par les valeurs appropriées de votre tenant. Pour en savoir plus, consultez le tableau des paramètres ci-dessous.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/organizations' \
    --header 'authorization: Bearer {MGMT_API_ACCESS_TOKEN}' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/organizations");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer {MGMT_API_ACCESS_TOKEN}");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }", 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/organizations"

  	payload := strings.NewReader("{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }")

  	req, _ := http.NewRequest("POST", 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.post("https://{yourDomain}/api/v2/organizations")
    .header("content-type", "application/json")
    .header("authorization", "Bearer {MGMT_API_ACCESS_TOKEN}")
    .header("cache-control", "no-cache")
    .body("{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/organizations',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer {MGMT_API_ACCESS_TOKEN}',
      'cache-control': 'no-cache'
    },
    data: '{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }'
  };

  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/organizations",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }",
    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 = "{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }"

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

  conn.request("POST", "/{yourDomain}/api/v2/organizations", 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/organizations")

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

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer {MGMT_API_ACCESS_TOKEN}'
  request["cache-control"] = 'no-cache'
  request.body = "{ "name": "ORG_NAME", "display_name": "ORG_DISPLAY_NAME", "branding": [ { "logo_url": "{orgLogo}", "colors": [ { "primary": "{orgPrimaryColor}", "page_background": "{orgPageBackground}" } ] } ], "metadata": [ { "{key}": "{value}", "{key}": "{value}", "{key}": "{value}" } ] }, "enabled_connections": [ { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" }, { "connection_id": "{connectionId}", "assign_membership_on_login": "{assignMembershipOption}" } ] }"

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  **Trouvez votre domaine Auth0**

  Votre domaine Auth0 correspond au nom de votre tenant, suivi de votre sous-domaine régional (sauf si votre tenant se trouve dans la région des États-Unis et a été créé avant juin 2020), puis de `.auth0.com`. Par exemple, si le nom de votre tenant était `travel0`, votre domaine Auth0 serait `travel0.us.auth0.com`. (Si votre tenant se trouvait aux États-Unis et avait été créé avant juin 2020, votre nom de domaine serait alors `https://travel0.auth0.com`.)

  Si vous utilisez des domaines personnalisés, il doit s’agir de votre nom de domaine personnalisé.
</Callout>

| **Valeur**                 | **Description**                                                                                                                                                                                                                                                                                                                                                                                                |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MGMT_API_ACCESS_TOKEN`    | [Jeton d’accès pour la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la portée `create:organizations`.                                                                                                                                                                                                                                                            |
| `ORG_NAME`                 | Nom de l’organisation que vous souhaitez créer. Il s’agit du nom qu’un utilisateur final saisirait dans l’invite de pré-connexion pour indiquer par quelle organisation il souhaite se connecter. Identifiant logique unique. Peut contenir des lettres minuscules, des chiffres, des traits de soulignement (`_`) et des tirets (`-`). Peut commencer par un chiffre. Doit contenir entre 1 et 50 caractères. |
| `ORG_DISPLAY_NAME`         | Facultatif. Nom convivial de l’organisation pouvant être affiché dans le flux de connexion et les modèles de courriel.                                                                                                                                                                                                                                                                                         |
| `ORG_LOGO`                 | Facultatif. URL du logo de l’organisation.                                                                                                                                                                                                                                                                                                                                                                     |
| `ORG_PRIMARY_COLOR`        | Facultatif. Code de couleur HEX pour les éléments principaux.                                                                                                                                                                                                                                                                                                                                                  |
| `ORG_BACKGROUND_COLOR`     | Facultatif. Code de couleur HEX pour l’arrière-plan.                                                                                                                                                                                                                                                                                                                                                           |
| `KEY`/`VALUE`              | Facultatif. Paires clé-valeur de type String représentant les métadonnées de l’organisation. Maximum de 255 caractères chacune. Maximum de 25 paires de métadonnées.                                                                                                                                                                                                                                           |
| `CONNECTION_ID`            | Facultatif. ID de la connexion que vous souhaitez activer pour l’organisation indiquée. Les connexions activées s’affichent dans l’invite de connexion de l’organisation, afin que les utilisateurs puissent accéder à vos applications par leur intermédiaire.                                                                                                                                                |
| `ASSIGN_MEMBERSHIP_OPTION` | Facultatif. Indique si vous souhaitez que les utilisateurs qui se connectent avec la connexion activée obtiennent automatiquement une appartenance à l’organisation indiquée. Lorsque cette option est définie sur `true`, les utilisateurs obtiennent automatiquement une appartenance. Lorsqu’elle est définie sur `false`, ils ne l’obtiennent pas automatiquement.                                         |

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

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

| **Code d’état** | **Code d’erreur**       | **Message**                                                                                            | **Cause**                                                                                                 |
| --------------- | ----------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------- |
| `201`           |                         | Organisation créée avec succès.                                                                        |                                                                                                           |
| `400`           | `invalid_body`          | Corps de la requête invalide. Le message varie selon la cause.                                         | La charge utile de la requête n’est pas valide.                                                           |
| `400`           | `invalid_query_string`  | Chaîne de requête invalide. Le message varie selon la cause.                                           | La chaîne de requête n’est pas valide.                                                                    |
| `401`           |                         | Jeton invalide.                                                                                        |                                                                                                           |
| `401`           |                         | Signature invalide reçue lors de la validation du JSON Web Token.                                      |                                                                                                           |
| `401`           |                         | Le client n’est pas global.                                                                            |                                                                                                           |
| `403`           | `insufficient_scope`    | Portée insuffisante; une des portées suivantes est requise : `create:organizations`.                   | Tentative de lire ou de modifier un champ qui n’est pas autorisé avec les portées du jeton Bearer fourni. |
| `409`           | `organization_conflict` | Une organisation portant le même nom existe déjà.                                                      | Une organisation portant le même nom existe déjà.                                                         |
| `429`           |                         | Trop de requêtes. Vérifiez les en-têtes X-RateLimit-Limit, X-RateLimit-Remaining et X-RateLimit-Reset. |                                                                                                           |