> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Configurer votre application pour l’accès communication entre machines (machine-to-machine/M2M)

> Découvrez comment configurer votre application pour l’accès communication entre machines (machine-to-machine/M2M) à l’aide d’Auth0 Dashboard et de Management API.

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

export const codeExample1 = `curl --request POST \\
  --url 'https://{yourDomain}/api/v2/client-grants' \\
  --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \\
  --header 'content-type: application/json' \\
  --data '{
    "client_id": "CLIENT_ID",
    "audience": "API_IDENTIFIER",
    "scope": [
        "scope1",
        "scope2"
    ],
    "organization_usage": "ORG_USAGE",
    "allow_any_organization": false
  }'
`;

export const codeExample2 = `curl --request PATCH \\
  --url 'https://{yourDomain}/api/v2/client-grants/CLIENT_GRANT_ID' \\
  --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \\
  --header 'content-type: application/json' \\
  --data '{
    "organization_usage": "ORG_USAGE",
    "allow_any_organization": false
  }'
`;

export const codeExample3 = `curl -X PATCH --location "https://{yourDomain}/api/v2/clients/{CLIENT_ID}" \\
  --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \\
  --header 'content-type: application/json' \\
  --data '{
    "default_organization": "ORGANIZATION_ID",
	  "flows": ["client_credentials"]
  }'
`;

Après avoir créé l’application, configurez-la pour l’accès communication entre machines en procédant comme suit :

1. [Définissez le comportement organisationnel](#define-organization-behavior) de chaque API à laquelle vous devez accéder.
2. Dans les cas où l’application ne doit accéder qu’à certaines organisations (et non à toutes), [autorisez l’accès communication entre machines (machine-to-machine/M2M)](/docs/fr-ca/manage-users/organizations/organizations-for-m2m-applications/authorize-m2m-access) pour chaque API à laquelle vous devez accéder pour ces organisations précises.

## Définir le comportement organisationnel

Vous pouvez configurer la façon dont votre application utilise les organisations lors du Flux des identifiants client pour chaque API, par exemple si l’application doit utiliser une organisation donnée ou si elle peut accéder à toute organisation, ou encore uniquement à celles liées explicitement.

Le tableau suivant explique les champs servant à définir le comportement organisationnel pour l’accès communication entre machines (machine-to-machine/M2M) :

### Tableau Définir le comportement organisationnel

| Champ                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Mappage d’API                                                                                                                                                                                                                             |
| -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Organization Support (Prise en charge des organizations) | Détermine la manière dont cette application peut utiliser des organizations lors de l’accès via le Flux des identifiants client.\<<br />Options possibles :<br /><br /><ul><li>**Aucune :** L’application *ne doit pas* utiliser d’organizations. Il s’agit de la valeur par défaut.</li><li>**Facultatif :** L’application *peut décider* d’utiliser ou non une organization.</li><li>**Obligatoire :** L’application *doit* utiliser une organization.</li></ul>                                             | La prise en charge de l’organization correspond à `organization_usage`.<br />Options :<br /><br /><ul><li>**Aucun** mappé à `deny`</li><li>**Facultatif** mappé à `allow`</li><li>**Obligatoire** mappé à `required`</li></ul>            |
| Autoriser l’accès machine à machine à toute organization | Détermine si cette application peut accéder à n’importe quelle organization ou est limitée à un ensemble d’organizations explicitement associées lors de l’utilisation du Flux des identifiants client. Par défaut, ce comportement n’est pas autorisé.<br />**Avertissement :** L’activation de l’accès machine à machine permet à l’application d’accéder à n’importe quelle organization sans qu’elle soit explicitement associée. Elle ne doit être activée que pour les applications internes approuvées. | Autoriser l’accès machine à machine à n’importe quelle organization correspond à `allow_any_organization`.<br />Options :<br /><br /><ul><li>La case cochée correspond à `true`</li><li>La case non cochée correspond à `false`</li></ul> |

### Définir le comportement organisationnel d’une application

Pour définir le comportement organisationnel d’une application, utilisez [Auth0 Dashboard](https://manage.auth0.com/) ou [Management API](https://auth0.com/docs/api/management/v2).

<Tabs>
  <Tab title="Auth0 Dashboard">
    Pour une application de communication entre machines, définissez le comportement d’organization à partir d’Auth0 Dashboard :

    1. Naviguez vers **Auth0 Dashboard > Applications**, et sélectionnez l’application pour laquelle vous souhaitez configurer les Organizations.
    2. Passez à l’onglet **API** et élargissez les détails `client_grant` pour l’API dont vous souhaitez configurer l’accès.
    3. Configurez les paramètres appropriés comme expliqué dans le tableau [Définir le comportement d’Organization](#define-organization-behavior-table).
    4. Sélect]\(/docs/images/ave (Enregistrer).\*\*

    <Frame>
      <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/fr-ca/cdy7uua7fh8z/2GYvtLuuDm1mgyLivYeqJh/a09082e1b3af85877cad397e989872a0/Acme_Bot_-_Travel0_API_Config.png" alt="" />
    </Frame>

    Autre possibilité, s’il ne s’agit pas d’une application de communication entre machines :

    1. Rendez-vous à **Tableau de bord Auth0 > API**, et sélectionnez l’API pour laquelle vous souhaitez configurer l’accès à Organizations.
    2. Passez à l’onglet **Machine To Machine Applications (Applications de communication entre machines)**. Toutes les applications, et pas seulement les applications de communication entre machines. Localisez votre application parmi la liste.
    3. Pour permettre l’accès, cliquez sur la bascule correspondant à votre application. Cliquez ensuite sur votre application pour afficher les détails de la configuration.
    4. Configurez les paramètres appropriés comme expliqué dans le tableau [Définir le comportement d’Organization](#define-organization-behavior-table).
    5. Sélect]\(/docs/images/ave (Enregistrer)\*\*.

    <Frame>
      <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/fr-ca/cdy7uua7fh8z/6wvsRl1mL4AbKzg5ycP8Pj/496c473bbe4823f03883707830373ab3/Travel0_API_-_M2M_Tab.png" alt="" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Vous pouvez également définir le comportement organisationnel d’une application à l’aide de Management API. L’objet `client_grant` contrôle l’accès de votre application à une API, où vous devez configurer le paramètre `client_grant` pour chaque API à laquelle votre application doit accéder. Pour configurer le paramètre `client_grant` pour l’accès M2M, utilisez les points de terminaison [Create client grant (Créer un octroi client)](https://auth0.com/docs/api/management/v2/client-grants/post-client-grants) ou [Update client grant (Mettre à jour l’octroi client)](https://auth0.com/docs/api/management/v2/client-grants/patch-client-grants-by-id) et le [tableau Définir le comportement de l’organisation](#define-organization-behavior-table) pour mettre à jour les paramètres appropriés.

    L’exemple de code suivant crée un objet `client_grant` avec un accès M2M :

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

    L’exemple de code suivant met à jour un objet `client_grant` avec un accès M2M :

    <AuthCodeBlock children={codeExample2} language="bash" />
  </Tab>
</Tabs>

## Définir l’organisation par défaut

Certains clients ne prennent pas en charge les champs non standard dans le [Flux des identifiants client](/docs/fr-ca/get-started/authentication-and-authorization-flow/client-credentials-flow). Par conséquent, ils ne peuvent pas envoyer le paramètre `organization` requis au point de terminaison `/oauth/token`. Pour ces clients, vous pouvez définir une organisation par défaut, appliquée automatiquement à toute demande d’identifiants client depuis l’application lorsque `none` est indiqué et que la prise en charge de l’organisation est `required` (requise) par l’API.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  L’organization par défaut est appliquée lorsque `organization_usage=require` pour l’API (c-à-d., l’audience cible).
</Callout>

Le tableau suivant explique les champs servant à définir une organisation pour l’accès communication entre machines :

### Tableau Définir l’organisation par défaut

| Champ                                               | Description                                                                                                                  | Mappage API                                                                                                                                                                                                                                                                                                                                                                                                            |
| --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Organization par défaut pour l’accès entre machines | Définit l’organization à appliquer aux demandes d’informations d’identification client qui ne contiennent pas d’organisation | Organization par défaut pour l’accès entre machines à l’objet default\_organization avec les propriétés suivantes :<ul><li>`organization_id` : Identifiant de l’organization à utiliser</li><li>`flows` : Le flux d’authentification à utiliser pour l’organization par défaut.<br />Ce paramètre est masqué dans l’interface utilisateur et prend par défaut la valeur `["client_credentials"]`<br /><br /></li></ul> |

### Définir l’organisation par défaut pour une application

Pour définir l’organisation par défaut d’une application, utilisez [Auth0 Dashboard](https://manage.auth0.com/) ou [Management API](https://auth0.com/docs/api/management/v2).

<Tabs>
  <Tab title="Auth0 Dashboard">
    Pour activer une organisation par défaut pour une application via Auth0 Dashboard :

    1. Naviguez vers **Auth0 Dashboard > Applications**, et sélectionnez l’application pour laquelle vous souhaitez configurer la MFA.
    2. Sélectionnez l’onglet **Organizations**.
    3. Configurez les paramètres appropriés comme expliqué dans le tableau [Set default organization (Définir l’organisation par défaut)](#set-default-organization-table).
    4. Clique]\(/docs/images/ve (Enregistrer)\*\*.

    <Frame>
      <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/fr-ca/cdy7uua7fh8z/29rhTFMnYDp7TbGS9S6b5J/e6b9d8280ae0c3e99547fc6b8ae1ac03/2025-07-18_15-55-48.png" alt="" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Vous pouvez configurer l’organization par défaut pour une application via les points de terminaison [Create a client (Créer un client)](https://auth0.com/docs/api/management/v2/clients/post-clients) ou [Update a client (Mettre à jour un client)](https://auth0.com/docs/api/management/v2#!/Clients/patch_clients_by_id). La seule valeur de flux actuellement prise en charge est `client_credentials`.

    L’exemple de code suivant met à jour un client avec une organization par défaut :

    <AuthCodeBlock children={codeExample3} language="bash" />
  </Tab>
</Tabs>
