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

# Applications propriétaires et tierces

> Découvrez la différence entre les applications propriétaires et les applications tierces sur Auth0.

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

Lorsque vous enregistrez une application dans Auth0, vous déterminez s’il s’agit d’une application propriétaire ou tierce selon l’entité qui en est propriétaire et qui l’exploite.

* Applications propriétaires : elles appartiennent à votre organisation et sont exploitées par celle-ci. Vous contrôlez leur déploiement, leurs identifiants et leur comportement.
* Applications tierces : elles appartiennent à une organisation externe et sont exploitées par celle-ci, par exemple un partenaire, un développeur indépendant ou un agent d’IA. Vous leur accordez l’accès à vos ressources, mais vous ne pouvez pas contrôler directement ce qu’elles font de cet accès.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  "Tierce" renvoie au contrôle opérationnel, et non à la paternité de l’application. Bon nombre d’organisations confient à des tiers le développement de leurs propres applications. Par exemple, un sous-traitant qui développe votre application n’en fait pas une application tierce. La distinction essentielle est la suivante : qui la déploie, qui détient les identifiants et qui peut l’arrêter.
</Callout>

Les classifications confidentielle/publique et propriétaire/tierce partie sont indépendantes. « Confidentielle » ou « publique » décrit la capacité d’authentification de l’application (autrement dit, si elle peut conserver un secret). « Propriétaire » ou « tierce partie » décrit la relation de confiance (qui est propriétaire de l’application et qui l’exploite).

Les applications propriétaires comme les applications tierces peuvent être confidentielles (Regular Web App) ou publiques (SPA, Native). Une Regular Web App tierce est à la fois confidentielle et tierce.

<div id="first-party-applications">
  ## Applications de première partie
</div>

Les applications de première partie sont contrôlées par la même organisation ou la même personne à qui appartient le domaine Auth0. Par exemple, supposons que vous ayez créé une API Contoso et une application qui se connecte à `contoso.com` et qui consomme l’API Contoso. Vous enregistreriez alors l’API et l’application sous le même domaine Auth0, et l’application serait une application de première partie. Par défaut, toutes les applications créées dans le [Auth0 Dashboard](https://manage.auth0.com/#/applications) sont des applications de première partie.

<div id="third-party-applications">
  ## Applications tierces
</div>

Les applications tierces sont contrôlées par une personne qui, selon toute vraisemblance, ne devrait pas avoir d’accès administratif à votre domaine Auth0. Les applications tierces permettent à des parties externes ou à des partenaires d’accéder de façon sécurisée à des ressources protégées par votre API.

Par exemple, si une entreprise partenaire crée un tableau de bord d’analyse de données pour visualiser les informations provenant de votre service, elle doit d’abord enregistrer son application dans votre locataire Auth0 afin d’obtenir un <Tooltip tip="ID client : valeur d’identification attribuée par Auth0 à votre ressource enregistrée." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=client+ID">ID client</Tooltip> et un secret. Même si cette application est enregistrée dans votre environnement, elle est considérée comme tierce, parce que le code et les identifiants appartiennent au partenaire et sont gérés par celui-ci, et non par votre organisation.

Toutes les applications créées au moyen de l’[Enregistrement dynamique des applications](/fr-CA/docs/get-started/applications/dynamic-client-registration) sont des applications tierces. Pour en savoir plus sur les applications tierces dans Auth0, consultez [Applications tierces](/fr-CA/docs/get-started/applications/third-party-applications).

<div id="first-party-vs-third-party-in-auth0">
  ## Applications propriétaires et tierces dans Auth0
</div>

Le tableau suivant résume les différences entre les applications propriétaires et tierces dans Auth0 :

|                                        | **Propriétaires**                               | **Tierces**                                                                                                                                                                                                                                                                |
| -------------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Accès à l’API**                      | Suit la stratégie d’accès configurée pour l’API | Exige toujours une [autorisation d’application](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants) explicite                                                                                                                                   |
| **API système d’Auth0**                | Accessibles dans les flux utilisateur           | Non accessibles dans les flux utilisateur                                                                                                                                                                                                                                  |
| **Consentement de l’utilisateur**      | Peut être omis (s’il est activé sur l’API)      | Toujours requis                                                                                                                                                                                                                                                            |
| **Types d’octroi**                     | Tous les types d’octroi pris en charge          | `authorization_code`, `refresh_token` et `client_credentials`                                                                                                                                                                                                              |
| **OIDC**                               | Pris en charge                                  | Non pris en charge. Prévu dans une version ultérieure.                                                                                                                                                                                                                     |
| **Rules**                              | Exécutées                                       | Non pris en charge. Génère une erreur.                                                                                                                                                                                                                                     |
| **Protocoles non OAuth** (SAML, WsFed) | Pris en charge                                  | Non pris en charge                                                                                                                                                                                                                                                         |
| **Organizations**                      | Pris en charge                                  | L’accès machine à machine est pris en charge au moyen des [autorisations d’application d’organisation](/fr-CA/docs/manage-users/organizations/configure-organizations/configure-organization-client-grants). Les flux utilisateur sont prévus dans une version ultérieure. |
| **Format de l’ID client**              | Format standard                                 | Préfixe `tpc_`                                                                                                                                                                                                                                                             |
| **Connexions**                         | Toutes les connexions activées                  | Connexions au niveau du domaine                                                                                                                                                                                                                                            |

Pour en savoir plus sur les applications tierces dans Auth0, consultez [Applications tierces](/fr-CA/docs/get-started/applications/third-party-applications).

<div id="application-ownership">
  ## Propriété de l’application
</div>

La propriété d’une application est établie au moment de sa création et ne peut pas être modifiée par la suite. Par défaut, les applications sont créées en tant qu’applications propriétaires, ce qui leur applique des paramètres de sécurité moins restrictifs. Pour vous assurer que les [contrôles de sécurité](/fr-CA/docs/get-started/applications/third-party-applications/security-controls) appropriés sont appliqués, vous devez identifier correctement comme tierces les applications appartenant à des parties externes lorsque vous les créez dans Auth0 Dashboard ou au moyen de la Management API. Pour savoir comment faire, consultez [Configurer les applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/configure-third-party-applications).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propriété d’une application est immuable. Vous ne pouvez pas convertir une application tierce en application propriétaire, ni l’inverse.
</Callout>

<div id="check-application-ownership">
  ## Vérifier le statut de propriété de l’application
</div>

Pour vérifier si une application est propriétaire ou tierce :

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > Applications**.
    2. Sélectionnez l’application. Les applications tierces portent un badge qui les identifie comme telles.

    <Frame>
      <img src="https://mintcdn.com/translations/S4csL9vq6QUX5-Rr/docs/images/third-party-applications/third-party-badge.png?fit=max&auto=format&n=S4csL9vq6QUX5-Rr&q=85&s=682354244f06a1fdeeb5cea2036e2cde" alt="Paramètres de l’application dans l’Auth0 Dashboard montrant le badge d’application tierce" width="433" height="67" data-path="docs/images/third-party-applications/third-party-badge.png" />
    </Frame>
  </Tab>

  <Tab title="Management API">
    Effectuez un appel `GET` vers le [endpoint Get a Client](https://auth0.com/docs/api/management/v2#!/Clients/get_clients_by_id). Assurez-vous de remplacer les valeurs de substitution `{YOUR_CLIENT_ID}`
    et `{YOUR_MANAGEMENT_API_ACCESS_TOKEN}` par votre <Tooltip tip="ID client : valeur d'identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=client+ID">ID client</Tooltip> et votre <Tooltip tip="Jeton d'accès : identifiant d'autorisation, sous forme de chaîne opaque ou de JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Access+Token">Jeton d'accès</Tooltip> du Management API, respectivement.

    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true' \
        --header 'authorization: Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'
      ```

      ```csharp C# theme={null}
      var client = new RestClient("https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true");
      var request = new RestRequest(Method.GET);
      request.AddHeader("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}");
      IRestResponse response = client.Execute(request);
      ```

      ```go Go theme={null}
      package main

      import (
      	"fmt"
      	"net/http"
      	"io/ioutil"
      )

      func main() {

      	url := "https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true"

      	req, _ := http.NewRequest("GET", url, nil)

      	req.Header.Add("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}")

      	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 response = Unirest.get("https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true")
        .header("authorization", "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}")
        .asString();
      ```

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

      var options = {
        method: 'GET',
        url: 'https://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}',
        params: {fields: 'is_first_party', include_fields: 'true'},
        headers: {authorization: 'Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'}
      };

      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://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_ENCODING => "",
        CURLOPT_MAXREDIRS => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        CURLOPT_CUSTOMREQUEST => "GET",
        CURLOPT_HTTPHEADER => [
          "authorization: Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}"
        ],
      ]);

      $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("")

      headers = { 'authorization': "Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}" }

      conn.request("GET", "/{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true", headers=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://{YOUR_DOMAIN}/api/v2/clients/{YOUR_CLIENT_ID}?fields=is_first_party&include_fields=true")

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

      request = Net::HTTP::Get.new(url)
      request["authorization"] = 'Bearer {YOUR_MANAGEMENT_API_ACCESS_TOKEN}'

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

    | Valeur                             | Description                                                                                                                                               |
    | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `YOUR_CLIENT_ID`                   | L’id de l’application à mettre à jour.                                                                                                                    |
    | `YOUR_MANAGEMENT_API_ACCESS_TOKEN` | [Jetons d’accès pour la Management API](https://auth0.com/docs/api/management/v2/tokens) avec le [scope](/fr-CA/docs/glossary?term=scope) `read:clients`. |

    Si l'application est propriétaire, le champ `is_first_party` aura la valeur `true`. Si l'application est tierce, le champ `is_first_party` aura la valeur `false`.
  </Tab>
</Tabs>

<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)
* [Applications confidentielles et publiques](/fr-CA/docs/get-started/applications/confidential-and-public-applications)
* [Consentement de l’utilisateur et applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)