> ## 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 les applications tierces

> Créez et configurez des applications tierces à l’aide de l’Auth0 Dashboard ou de la 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) + "*****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>;
};

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 mesures de sécurité renforcées.

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

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

* Un tenant Auth0 avec au moins une [API (serveur de ressources)](/docs/fr-ca/get-started/apis) configurée
* Au moins une [connexion](/docs/fr-ca/authenticate/identity-providers) promue au [niveau du domaine](/docs/fr-ca/authenticate/identity-providers/promote-connections-to-domain-level) (pour les flux destinés aux utilisateurs)

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

Créez une application tierce à l’aide de l’Auth0 Dashboard ou de la Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > Applications**.
    2. Sélectionnez **Create Application**.
    3. Entrez 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 le navigateur
       * Native pour les clients publics sur mobile ou ordinateur de bureau
    4. Activez la 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 la bascule pour 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">
    Envoyez une requête `POST` au 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 de première partie (`true`) ou tierce (`false`).                                                                                                                                                                                                                                                                        |
    | `app_type`                   | String   | Le type d’application (p. ex., `regular_web`, `native`, `spa`, `non_interactive`).                                                                                                                                                                                                                                                                   |
    | `callbacks`                  | Array    | Une liste des callback URLs autorisées pour la redirection après l’authentification.                                                                                                                                                                                                                                                                 |
    | `grant_types`                | Array    | Une liste des grant types OAuth2 que ce client est autorisé à 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](/docs/fr-ca/get-started/applications/third-party-applications/security-controls). |
    | `token_endpoint_auth_method` | String   | La méthode d’authentification pour le Token point de terminaison (p. ex., `client_secret_post`).                                                                                                                                                                                                                                                     |

    En cas de succès, Auth0 crée l’application avec un préfixe de Client ID `tpc_`, les grant types `authorization_code` et `refresh_token`, et définit `third_party_security_mode` à `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   | L’identifiant unique de l’application avec un préfixe `tpc` pour indiquer 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é. Réglez-le à `strict` pour appliquer des contraintes de sécurité renforcées aux applications tierces.               |
    | `is_first_party`            | Boolean  | Doit être défini à `false` lorsque le mode de sécurité `strict` est utilisé pour identifier l’application comme tierce.                           |
    | `name`                      | String   | Le nom d’affichage de l’application.                                                                                                              |
    | `grant_types`               | Array    | Les grant types OAuth2 que cette application est autorisée à utiliser (p. ex., `authorization_code`).                                             |
  </Tab>
</Tabs>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propriété `third_party_security_mode` est définie à 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 nécessitent des client grants explicites pour accéder aux API. Vous pouvez configurer les politiques d’accès aux API des façons suivantes :

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

Lorsque des permissions par application et des permissions par défaut pour les applications tierces existent pour la même API, les permissions par application prévalent. Pour en savoir plus, consultez [Application Access to APIs: Client Grants](/docs/fr-ca/get-started/applications/application-access-to-apis-client-grants).

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

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

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Allez à l’onglet **Settings**.
    3. Faites défiler jusqu’à **Application Access Policy** et définissez **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 de l’API dans le Dashboard pour Application Access Policy" width="1958" height="600" data-path="docs/images/third-party-applications/application_access_policy.png" />
    </Frame>

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

    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Allez à l’onglet **Application Access**.
    3. Faites défiler jusqu’à 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 de l’API dans le Dashboard pour accorder l’accès à l’API à l’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 le client grant.                                                                                                                                                                                                                                                      |
      | `audience`     | String   | L’identifiant unique (URI) de l’API pour laquelle le grant est créé.                                                                                                                                                                                                                                                        |
      | `scope`        | Array    | Une liste d’autorisations (scopes) permises dans le cadre de ce grant.                                                                                                                                                                                                                                                      |
      | `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 flows qui génèrent un token associé à un utilisateur final.</li><li>`client` : utilisé pour l’accès machine-to-machine, comme le Client Credentials Flow.</li></ul> |
    </AuthCodeGroup>
  </Tab>
</Tabs>

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

Les permissions par défaut définissent un ensemble de base d’API et de scopes accessibles à toutes les applications tierces. Cette configuration est requise pour [enregistrement dynamique des clients](/docs/fr-ca/get-started/applications/dynamic-client-registration), puisqu’il n’est pas possible de configurer l’accès pour chaque application individuellement.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > APIs** et sélectionnez l’API.
    2. Allez à 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 permissions 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 la 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 ce grant est appliqué automatiquement à certains types d’applications. Définissez-le 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 le grant est créé.                                                                                                                                                                                                                                                   |
    | `scope`        | Array    | Une liste de permissions (scopes) autorisées dans le cadre de ce grant.                                                                                                                                                                                                                                                |
    | `subject_type` | String   | Définit le type d’accès applicatif 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 token associé à un utilisateur final.</li><li>`client` : utilisé pour l’accès machine à machine, comme le Client Credentials Flow.</li></ul> |
  </Tab>
</Tabs>

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

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

Pour promouvoir une connexion :

1. Accédez à **Auth0 Dashboard > Authentification** et sélectionnez le type de connexion (Database, Social, Enterprise).
2. Sélectionnez la connexion que vous souhaitez utiliser avec des applications tierces.
3. Activez la bascule **Promote Connection to Domain Level**.

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les applications tierces peuvent accéder à une connexion qui n’est pas promue au niveau du domaine par l’intermédiaire de [Cross App Access (XAA)](/docs/fr-ca/ai-agents-mcp/cross-app-access), à condition que l’accès soit autorisé dans l’IdP d’entreprise. Ne promouvez une connexion au niveau du domaine que si vous souhaitez que toute application tierce puisse y accéder à la fois par les flux de connexion standard (point de terminaison `/authorize`) et par XAA. Si vous souhaitez que XAA soit le seul moyen pour les applications tierces d’obtenir des jetons par cette connexion, ne la promouvez pas au niveau du domaine.
</Callout>

<div id="configure-organizations-access">
  ## Configurer l’accès aux Organizations
</div>

Pour que les utilisateurs puissent s’authentifier au moyen d’une application tierce dans le contexte d’une [Organization](/docs/fr-ca/manage-users/organizations), deux conditions doivent être remplies :

1. La connexion doit être promue au [niveau du domaine](/docs/fr-ca/authenticate/identity-providers/promote-connections-to-domain-level), comme décrit dans la section ci-dessus.
2. L’Organization doit avoir `third_party_client_access` défini à `allow`.

Si l’une ou l’autre de ces conditions n’est pas remplie, la demande d’autorisation échoue avec `invalid_request`. Pour activer l’accès d’une application tierce à une Organization, consultez [Activer l’accès des applications tierces pour une Organization](/docs/fr-ca/manage-users/organizations/configure-organizations/enable-third-party-application-access).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Puisque les applications tierces sont contrôlées par des développeurs externes, vous ne pouvez pas garantir qu’elles transmettent le paramètre `organization` dans les requêtes d’autorisation. Configurez [Prompt for Credentials ou Prompt for Organization](/docs/fr-ca/manage-users/organizations/login-flows-for-organizations) dans votre application afin que les utilisateurs soient dirigés vers le bon contexte d’Organization.
</Callout>

Pour l’accès de machine à machine avec Organizations, les applications tierces nécessitent un `organization_client_grant` explicite pour chaque Organization. `allow_any_organization` n’est pas disponible. Pour en savoir plus, consultez [Organizations for M2M Applications](/docs/fr-ca/manage-users/organizations/organizations-for-m2m-applications).

Le consentement est associé au contexte d’Organization. Un utilisateur qui donne son consentement dans une Organization doit le redonner s’il accède à la même application par l’intermédiaire d’une autre Organization. Pour en savoir plus, consultez [Consent with Organizations](/docs/fr-ca/get-started/applications/third-party-applications/user-consent-and-third-party-applications#consent-with-organizations).

<div id="behavior-summary">
  ### Résumé du comportement
</div>

| **Flux**               | **`third_party_client_access: allow` requis ?** | **Connexion au domaine requise ?** | **`allow_any_organization`** |
| ---------------------- | ----------------------------------------------- | ---------------------------------- | ---------------------------- |
| Code d’autorisation    | Oui                                             | Oui                                | S. O.                        |
| Identifiants du client | Non — non évalué                                | Non                                | Non autorisé                 |

<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 la **Protection contre les redirections ouvertes** 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 la **Protection contre les redirections ouvertes** uniquement pour les applications tierces dont les URI de rappel configurées sont dignes de confiance. Pour en savoir plus, consultez [Redirect Protection](/docs/fr-ca/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. Accédez à 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="Bascule de la protection contre les redirections ouvertes 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 clients
</div>

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

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

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