> ## 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 de première partie et applications tierces

> Découvrez la différence entre les applications de première partie et les applications tierces dans 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) + "*****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>;
};

Lorsque vous enregistrez une application dans Auth0, vous décidez si elle est de première partie ou tierce selon l’entité qui la possède et l’exploite.

* **Les applications de première partie** appartiennent à votre organisation et sont exploitées par celle-ci. Vous contrôlez leur déploiement, leurs identifiants et leur comportement.

* **Les applications tierces** 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 avec cet accès.

  "Tierce" renvoie au contrôle opérationnel, et non à la création. De nombreuses organisations confient à l’externe le développement de leurs propres applications. Par exemple, le fait qu’un sous-traitant 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.

Les applications de première partie comme les applications tierces peuvent être confidentielles (applications Web traditionnelles) ou publiques (SPA, applications natives).

<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 possède le domaine Auth0. Par exemple, supposons que vous ayez créé une API Contoso et une application qui se connecte à `contoso.com` et consomme l’API Contoso. Vous enregistreriez à la fois l’API et l’application sous le même domaine Auth0, et l’application serait alors 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 aux ressources protégées derrière votre API.

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

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

<div id="first-party-vs-third-party-in-auth0">
  ## de première partie et tierce dans Auth0
</div>

Le tableau suivant résume les différences entre les applications de première partie et tierces dans Auth0 :

|                                        | **de première partie**                        | **tierce**                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------------------------- | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Accès à l’API**                      | Suit la politique d’accès configurée de l’API | Exige toujours un [client grant](/docs/fr-ca/get-started/applications/application-access-to-apis-client-grants) explicite                                                                                                                                                                                                                                                                                   |
| **API système Auth0**                  | Accessibles dans les flows utilisateur        | Non accessibles dans les flows utilisateur                                                                                                                                                                                                                                                                                                                                                                  |
| **Consentement de l’utilisateur**      | Peut être omis (si activé sur l’API)          | Toujours requis                                                                                                                                                                                                                                                                                                                                                                                             |
| **Grant types**                        | Tous les types de grant pris en charge        | `authorization_code`, `refresh_token` et `client_credentials`                                                                                                                                                                                                                                                                                                                                               |
| **OIDC**                               | Pris en charge                                | Non pris en charge. Prévu dans une prochaine version.                                                                                                                                                                                                                                                                                                                                                       |
| **Rules**                              | Exécutées                                     | Non pris en charge. Provoque une erreur.                                                                                                                                                                                                                                                                                                                                                                    |
| **Protocoles non OAuth** (SAML, WsFed) | Pris en charge                                | Non pris en charge                                                                                                                                                                                                                                                                                                                                                                                          |
| **Organizations**                      | Pris en charge                                | Pris en charge. Les flows utilisateur exigent que l’organisation [autorise l’accès aux applications tierces](/docs/fr-ca/manage-users/organizations/configure-organizations/enable-third-party-application-access). L’accès `client_credentials` est pris en charge via [Accès machine-to-machine (M2M) pour les Organizations](/docs/fr-ca/manage-users/organizations/organizations-for-m2m-applications). |
| **Format du Client ID**                | Format standard                               | Préfixe `tpc_`                                                                                                                                                                                                                                                                                                                                                                                              |
| **Connections**                        | Toutes les connexions activées                | Connexions au niveau du domaine                                                                                                                                                                                                                                                                                                                                                                             |

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

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

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

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

<div id="check-application-ownership">
  ## Vérifier à qui appartient l’application
</div>

Pour vérifier si une application est de première partie ou tierce :

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à **Applications > Applications**.
    2. Sélectionnez l’application. Les applications tierces affichent un badge indiquant qu’il s’agit d’applications tierces.

    <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 le 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 des espaces réservés `{YOUR_CLIENT_ID}` et `{YOUR_MANAGEMENT_API_ACCESS_TOKEN}` par votre <Tooltip tip="Client ID : valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=client+ID">client ID</Tooltip> et le jeton d’accès de l’API Management <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="/docs/fr-ca/glossary?term=Access+Token">Access Token</Tooltip>, 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_PEER

      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 la [portée](/docs/fr-ca/glossary?term=scope) `read:clients`. |

    Si l'application est de première partie, 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](/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)
* [Applications confidentielles et publiques](/docs/fr-ca/get-started/applications/confidential-and-public-applications)
* [Consentement de l’utilisateur et applications tierces](/docs/fr-ca/get-started/applications/third-party-applications/user-consent-and-third-party-applications)