> ## 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.

# Configurer des applications tierces

> Créez et configurez des applications tierces dans Auth0 Dashboard ou au moyen de Management API.

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

Créez des applications tierces qui permettent à des développeurs externes, à des partenaires ou à des agents d’IA d’accéder à vos API grâce à des contrôles de sécurité renforcés.

<div id="prerequisites">
  ## Prérequis
</div>

Avant de créer une application tierce, assurez-vous d’avoir :

* Un locataire Auth0 avec au moins une [API (serveur de ressources)](/fr-CA/docs/get-started/apis) configurée
* Au moins une [connexion](/fr-CA/docs/authenticate/identity-providers) promue au [niveau du domaine](/fr-CA/docs/authenticate/identity-providers/promote-connections-to-domain-level) (pour les flux côté utilisateur)

<div id="create-a-third-party-application">
  ## Créer une application tierce
</div>

Créez une application tierce dans l’Auth0 Dashboard ou avec la Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > Applications**.
    2. Sélectionnez **Create Application**.
    3. Saisissez un nom pour l’application et sélectionnez le type d’application :
       * Regular Web App pour les clients confidentiels côté serveur
       * Single Page App pour les clients publics basés sur navigateur
       * Native pour les clients publics mobiles ou de bureau
    4. Activez le bouton bascule **This application is owned by a third party**.
    5. Sélectionnez **Create**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/create-application-dialog.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=40a37dfc84c4d1323bc22244e405d846" alt="Boîte de dialogue Create Application du Dashboard avec l’option d’application tierce activée" width="800" height="875" data-path="docs/images/third-party-applications/create-application-dialog.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Effectuez une requête `POST` vers le point de terminaison `/api/v2/clients` avec le corps de requête suivant :

    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/clients' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "name": "Partner Application",
          "is_first_party": false,
          "app_type": "regular_web",
          "callbacks": ["https://partner.example.com/callback"],
          "grant_types": ["authorization_code", "refresh_token"],
          "token_endpoint_auth_method": "client_secret_post"
        }'
      ```
    </AuthCodeGroup>

    | **Paramètre**                | **Type** | **Description**                                                                                                                                                                                                                                                                                                                                        |
    | ---------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
    | `name`                       | String   | Obligatoire. Le nom de l’application.                                                                                                                                                                                                                                                                                                                  |
    | `is_first_party`             | Boolean  | Indique si l’application est propriétaire (`true`) ou tierce (`false`).                                                                                                                                                                                                                                                                                |
    | `app_type`                   | String   | Le type d’application (par ex. `regular_web`, `native`, `spa`, `non_interactive`).                                                                                                                                                                                                                                                                     |
    | `callbacks`                  | Array    | Liste des URL de rappel autorisées pour la redirection après l’authentification.                                                                                                                                                                                                                                                                       |
    | `grant_types`                | Array    | Liste des types de subvention OAuth2 que cette application peut utiliser. Les applications tierces prennent en charge `authorization_code`, `refresh_token` et `client_credentials`. Pour en savoir plus, consultez [Security Controls for Third-Party Applications](/fr-CA/docs/get-started/applications/third-party-applications/security-controls). |
    | `token_endpoint_auth_method` | String   | La méthode d’authentification du point de terminaison de jeton (par ex. `client_secret_post`).                                                                                                                                                                                                                                                         |

    Si la requête réussit, Auth0 crée l’application avec un préfixe d’ID client `tpc_`, les types de subvention `authorization_code` et `refresh_token`, et définit `third_party_security_mode` sur `strict`, ce qui indique que des contrôles de sécurité renforcés sont activés.

    ```json wrap lines theme={null}
    {
      "client_id": "tpc_aBcDeFgHiJkLmNoPqRsTuV",
      "third_party_security_mode": "strict",
      "is_first_party": false,
      "name": "Partner Application",
      "grant_types": ["authorization_code", "refresh_token"],
      ...
    }
    ```

    | **Paramètre**               | **Type** | **Description**                                                                                                                             |
    | --------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
    | `client_id`                 | String   | Identifiant unique de l’application avec un préfixe `tpc` indiquant qu’il s’agit d’une application tierce créée avec le mode strict activé. |
    | `third_party_security_mode` | String   | Définit le profil de sécurité. Définissez-le sur `strict` pour appliquer des contraintes de sécurité renforcées aux applications tierces.   |
    | `is_first_party`            | Boolean  | Doit être défini sur `false` lorsque vous utilisez le mode de sécurité `strict` pour identifier l’application comme tierce.                 |
    | `name`                      | String   | Le nom d’affichage de l’application.                                                                                                        |
    | `grant_types`               | Array    | Les types de subvention OAuth2 que cette application est autorisée à utiliser (par ex. `authorization_code`).                               |
  </Tab>
</Tabs>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propriété `third_party_security_mode` est définie lors de la création et ne peut pas être modifiée. Pour utiliser un autre mode de sécurité, créez une nouvelle application.
</Callout>

<div id="configure-api-access-policies">
  ## Configurer les politiques d’accès aux API
</div>

Les applications tierces ont besoin d’autorisations client explicites pour accéder aux API. Vous pouvez configurer les politiques d’accès aux API des façons suivantes :

* [Autorisations par application](#per-application-permissions) : appliquez des autorisations granulaires à chaque application de votre locataire.
* [Autorisations par défaut pour toutes les applications tierces](#default-permissions-for-all-third-party-applications) : appliquez des autorisations par défaut à toutes les applications tierces de votre locataire.

Lorsque des autorisations par application et des autorisations par défaut pour les applications tierces existent pour la même API, les autorisations par application ont préséance. Pour en savoir plus, consultez [Accès des applications aux API : Client Grants](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants).

<div id="per-application-permissions">
  ### Autorisations par application
</div>

Pour accorder à une application tierce précise un accès plus étendu ou plus limité que celui par défaut, créez une autorisation client pour le `client_id` de cette application :

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Ouvrez l’onglet **Settings**.
    3. Faites défiler jusqu’à **Application Access Policy** et réglez **User-Delegated Access** et **Client Access** sur **Per-app authorization**.
    4. Sélectionnez **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/application_access_policy.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=99767f91f6ed62363a1a0fde1a8f41b4" alt="Paramètres d’API du Dashboard pour la politique d’accès des applications" width="1958" height="600" data-path="docs/images/third-party-applications/application_access_policy.png" />
    </Frame>

    Lorsque vous configurez des autorisations par application, vous devez autoriser l’accès à l’API individuellement pour chaque application :

    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Ouvrez l’onglet **Application Access**.
    3. Repérez l’application, sélectionnez **Edit**, puis **Grant Access** pour **User-Delegated Access** et/ou **Client Access**. Sélectionnez ensuite les autorisations voulues.
    4. Sélectionnez **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/grant-api-access.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=57f8a27e6e446ae919139b0ca3caebd9" alt="Paramètres d’API du Dashboard pour accorder l’accès à l’API à une application" width="2002" height="128" data-path="docs/images/third-party-applications/grant-api-access.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/client-grants' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "client_id": "tpc_aBcDeFgHiJkLmNoPqRsTuV",
          "audience": "https://api.example.com",
          "scope": ["read:items", "write:items", "delete:items"],
          "subject_type": "user"
        }'
      ```

      | **Paramètre**  | **Type** | **Description**                                                                                                                                                                                                                                                                                                           |
      | -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `client_id`    | String   | Indique l’application pour laquelle vous voulez créer l’autorisation client.                                                                                                                                                                                                                                              |
      | `audience`     | String   | L’identifiant unique (URI) de l’API pour laquelle l’autorisation est créée.                                                                                                                                                                                                                                               |
      | `scope`        | Array    | Une liste d’autorisations (scopes) permises dans le cadre de cette autorisation.                                                                                                                                                                                                                                          |
      | `subject_type` | String   | Définit le type d’accès d’application autorisé pour l’API :<br /><ul><li>`user` : utilisé pour l’accès délégué par l’utilisateur, ce qui correspond aux flux qui génèrent un jeton associé à un utilisateur final.</li><li>`client` : utilisé pour l’accès machine à machine, comme le flux Client Credentials.</li></ul> |
    </AuthCodeGroup>
  </Tab>
</Tabs>

<div id="default-permissions-for-all-third-party-applications">
  ### Autorisations par défaut pour toutes les applications tierces
</div>

Les autorisations par défaut définissent un ensemble de base d’API et de scopes accessibles à toutes les applications tierces. Cela est nécessaire pour la [Enregistrement dynamique des applications](/fr-CA/docs/get-started/applications/dynamic-client-registration), car vous ne pouvez pas configurer l’accès pour chaque application individuellement.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Ouvrez l’onglet **Settings**.
    3. Faites défiler jusqu’à **Default Permissions for Third Party Apps**.
    4. Sélectionnez **Authorized** pour **User-Delegated Access** ou **Client Access**.
    5. Sélectionnez les scopes à accorder, puis cliquez sur **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/default-permissions-settings.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=b39ad27ef58bf44bde053a01cd514202" alt="Paramètres de l’API dans le Dashboard avec les autorisations par défaut pour les applications tierces" width="1954" height="1022" data-path="docs/images/third-party-applications/default-permissions-settings.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Effectuez une requête `POST` vers le point de terminaison `/api/v2/client-grants` avec le corps de requête suivant :

    <AuthCodeGroup>
      ```bash cURL wrap lines theme={null}
      curl --request POST \
        --url 'https://YOUR_DOMAIN/api/v2/client-grants' \
        --header 'Authorization: Bearer YOUR_MANAGEMENT_API_TOKEN' \
        --header 'Content-Type: application/json' \
        --data '{
          "default_for": "third_party_clients",
          "audience": "https://api.example.com",
          "scope": ["read:items", "write:items"],
          "subject_type": "user"
        }'
      ```
    </AuthCodeGroup>

    | **Paramètre**  | **Type** | **Description**                                                                                                                                                                                                                                                                                                                |
    | -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
    | `default_for`  | String   | Indique si cette autorisation est appliquée automatiquement à certains types d’applications. Définissez-la sur `third_party_clients` pour que toutes les applications tierces aient accès à cette API par défaut.                                                                                                              |
    | `audience`     | String   | L’identifiant unique (URI) de l’API pour laquelle l’autorisation est créée.                                                                                                                                                                                                                                                    |
    | `scope`        | Array    | La liste des permissions (scopes) autorisées dans le cadre de cette autorisation.                                                                                                                                                                                                                                              |
    | `subject_type` | String   | Définit le type d’accès à l’API autorisé pour l’application :<br /><ul><li>`user` : utilisé pour l’accès délégué par l’utilisateur, ce qui correspond aux flux qui génèrent un jeton associé à un utilisateur final.</li><li>`client` : utilisé pour l’accès de machine à machine, comme le flux Client Credentials.</li></ul> |
  </Tab>
</Tabs>

<div id="configure-connections">
  ## Configurer les connexions
</div>

Les applications tierces peuvent uniquement authentifier les utilisateurs par l’entremise de connexions au niveau du domaine. Lorsqu’une connexion est promue au niveau du domaine, elle devient accessible à toutes les applications tierces du locataire.

Pour promouvoir une connexion :

1. Accédez à **Auth0 Dashboard > Authentication** et sélectionnez le type de connexion (Base de données, Sociale, Entreprise).
2. Sélectionnez la connexion que vous souhaitez utiliser avec des applications tierces.
3. Activez le bouton bascule **Promote Connection to Domain Level**.

Pour en savoir plus, consultez [Faire passer les connexions au niveau du domaine](/fr-CA/docs/authenticate/identity-providers/promote-connections-to-domain-level).

<div id="configure-open-redirect-protection">
  ## Configurer la protection contre les redirections ouvertes
</div>

Les applications tierces dotées de contrôles de sécurité renforcés ont **Open Redirect Protection** activée par défaut. Lorsqu’elle est activée, Auth0 ne :

* redirige pas vers l’URL de rappel de l’application en cas d’erreur d’authentification
* n’expose pas `application.callback_domain` dans les modèles de courriel

Désactivez **Open Redirect Protection** uniquement pour les applications tierces dont les URI de rappel configurées sont fiables. Pour en savoir plus, consultez [Redirect Protection](/fr-CA/docs/get-started/applications/third-party-applications/security-controls#redirect-protection).

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > Applications** et sélectionnez l’application tierce.
    2. Ouvrez l’onglet **Settings** et faites défiler jusqu’à **Open Redirect Protection**.
    3. Activez ou désactivez ce paramètre.
    4. Sélectionnez **Save**.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/open-redirect-protection.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=5219fdc46874d2892accf5fd161a16af" alt="Commutateur Open Redirect Protection dans le Dashboard" width="581" height="177" data-path="docs/images/third-party-applications/open-redirect-protection.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Définissez la propriété `redirection_policy` lors de la création ou de la mise à jour de l’application :

    ```bash theme={null}
    curl --request PATCH \
      --url 'https://{yourDomain}/api/v2/clients/{CLIENT_ID}' \
      --header 'Authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
      --header 'Content-Type: application/json' \
      --data '{
        "redirection_policy": "allow_always"
      }'
    ```

    Définissez-la sur `open_redirect_protection` pour l’activer (par défaut) ou sur `allow_always` pour la désactiver.
  </Tab>
</Tabs>

<div id="dynamic-client-registration">
  ## Enregistrement dynamique des applications
</div>

Toutes les [applications enregistrées dynamiquement](/fr-CA/docs/get-started/applications/dynamic-client-registration) sont des applications tierces. Avant d’activer le DCR, configurez les [autorisations d’API par défaut](#default-permissions-for-all-third-party-applications) pour que les applications enregistrées dynamiquement puissent accéder à vos API.

<div id="learn-more">
  ## En savoir plus
</div>

* [Applications tierces](/fr-CA/docs/get-started/applications/third-party-applications)
* [Contrôles de sécurité pour les applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/security-controls)
* [Consentement de l’utilisateur et applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)
* [Enregistrement dynamique des applications](/fr-CA/docs/get-started/applications/dynamic-client-registration)
* [Faire passer les connexions au niveau du domaine](/fr-CA/docs/authenticate/identity-providers/promote-connections-to-domain-level)