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

> Découvrez comment effectuer l’enregistrement dynamique d’applications tierces avec Auth0.

# Enregistrement dynamique des applications

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

Vous pouvez enregistrer dynamiquement des applications tierces pour votre locataire. L’enregistrement dynamique des applications (DCR) s’appuie sur la [spécification OpenID Connect Dynamic Client Registration](https://openid.net/specs/openid-connect-registration-1_0.html).

Toutes les applications créées au moyen de l’enregistrement dynamique des applications sont des [applications tierces](/fr-CA/docs/get-started/applications/third-party-applications) assorties de [contrôles de sécurité renforcés](/fr-CA/docs/get-started/applications/third-party-applications/security-controls). Cela signifie que les applications DCR :

* Reçoivent un ID client avec le préfixe `tpc_`
* Exigent PKCE pour les flux de code d’autorisation
* Prennent en charge uniquement les types d’octroi `authorization_code` et `refresh_token`. Le type d’octroi `client_credentials` n’est pas offert avec DCR.
* Peuvent accéder aux API uniquement au moyen d’[autorisations d’application](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants) explicites
* Peuvent utiliser uniquement des [connexions au niveau du domaine](/fr-CA/docs/authenticate/identity-providers/promote-connections-to-domain-level) pour l’authentification

<div id="enable-dynamic-client-registration">
  ## Activer l’enregistrement dynamique des applications
</div>

<Warning>
  Auth0 prend en charge Open Dynamic Registration. Si cette option est activée, n’importe qui pourra créer des applications dans votre locataire sans jeton.
</Warning>

Par défaut, l’enregistrement dynamique des applications est désactivé pour tous les locataires. Pour activer l’enregistrement dynamique des applications, utilisez l’Auth0 Dashboard ou la Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à [Dashboard > Settings > Advanced](https://manage.auth0.com/#/tenant/advanced) et activez **Dynamic Client Registration (DCR)**.
  </Tab>

  <Tab title="Management API">
    Définissez l’indicateur `enable_dynamic_client_registration` sur `true` dans les paramètres de votre locataire à l’aide du point de terminaison [`/api/v2/tenants/settings`](https://auth0.com/docs/api/management/v2#!/Tenants/patch_settings).

    <AuthCodeGroup>
      ```bash cURL theme={null}
      curl --request PATCH \
        --url 'https://{yourDomain}/api/v2/tenants/settings' \
        --header 'authorization: Bearer {YOUR_MANAGEMENT_API_TOKEN}' \
        --header 'content-type: application/json' \
        --data '{ "flags": { "enable_dynamic_client_registration": true } }'
      ```
    </AuthCodeGroup>

    Vous devez remplacer `{YOUR_MANAGEMENT_API_TOKEN}` par un jeton valide ayant le scope `update:tenant_settings`. Pour en savoir plus, consultez [jetons d’accès de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens).
  </Tab>
</Tabs>

<div id="configure-api-access-for-dcr-clients">
  ## Configurer l’accès aux API pour les applications DCR
</div>

Avant d’activer DCR, configurez les [autorisations par défaut pour les applications tierces](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants#default-permissions-for-third-party-applications) sur les API auxquelles les applications enregistrées dynamiquement doivent avoir accès. Sans autorisations par défaut, les applications DCR ne pourront accéder à aucune API.

Les autorisations par défaut définissent un ensemble de base d’API et de scopes automatiquement accessibles à toutes les applications tierces. C’est essentiel pour DCR, car vous ne pouvez pas configurer des autorisations d’application pour chaque application pendant le flux d’enregistrement.

Pour savoir comment configurer les autorisations par défaut, consultez [Configurer les applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/configure-third-party-applications#default-permissions-for-all-third-party-applications).

<div id="register-an-application">
  ## Enregistrer une application
</div>

Pour enregistrer dynamiquement une application, envoyez une requête `POST` au point de terminaison `/oidc/register`. Comme Auth0 prend en charge l’enregistrement dynamique ouvert, le point de terminaison `/oidc/register` accepte les requêtes d’enregistrement sans jeton d’accès.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oidc/register' \
    --header 'content-type: application/json' \
    --data '{
      "client_name": "My Dynamic Application",
      "redirect_uris": ["https://application.example.com/callback"],
      "token_endpoint_auth_method": "none",
      "grant_types": ["authorization_code", "refresh_token"],
      "response_types": ["code"]
    }'
  ```
</AuthCodeGroup>

| **Paramètre**                | **Description**                                                                                                                                                                                                                                    |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `client_name`                | Le nom de l’application à créer.                                                                                                                                                                                                                   |
| `redirect_uris` (required)   | Un tableau d’URL qu’Auth0 accepte comme URL de redirection valides à la fin d’un flux d’authentification.                                                                                                                                          |
| `token_endpoint_auth_method` | La méthode d’authentification du point de terminaison de jeton. Utilisez `none` pour les applications publiques (SPA, natives) ou `client_secret_post` (par défaut) pour les applications confidentielles.                                         |
| `grant_types`                | Les types d’octroi que l’application souhaite utiliser. Ils sont filtrés dans la réponse pour refléter ceux qu’elle sera autorisée à utiliser. Les applications créées au moyen de DCR prennent en charge `authorization_code` et `refresh_token`. |
| `response_types`             | Les types de réponse que l’application utilisera. Utilisez `code` pour le flux de code d’autorisation.                                                                                                                                             |

Si la requête réussit, Auth0 renvoie les identifiants de l’application :

```json theme={null}
{
  "client_name": "My Dynamic Application",
  "client_id": "tpc_8SXWY6j3afl2CP5ntwEOpMdPxxy49Gt2",
  "client_secret": "Q5O...33P",
  "redirect_uris": [
    "https://application.example.com/callback"
  ],
  "client_secret_expires_at": 0,
  "grant_types": ["authorization_code", "refresh_token"],
  "token_endpoint_auth_method": "none"
}
```

| **Champ**                  | **Description**                                                                                                         |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `client_id`                | Identifiant unique de l’application avec le préfixe `tpc_`. Utilisez-le pour lancer des flux d’authentification.        |
| `client_secret`            | Secret client pour les applications confidentielles. N’est pas renvoyé lorsque `token_endpoint_auth_method` est `none`. |
| `client_secret_expires_at` | Heure d’expiration du secret client. Toujours `0` (n’expire jamais) pour Auth0.                                         |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les développeurs tiers ne peuvent pas modifier les paramètres de l’application après l’enregistrement. Si des changements sont nécessaires, ils doivent communiquer avec le propriétaire du locataire.
</Callout>

Après l’enregistrement, l’application peut lancer un [flux de code d’autorisation avec PKCE](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce) à l’aide du `client_id` et des `redirect_uris` configurés.

<div id="tenant-access-control-list-acl">
  ## Liste de contrôle d’accès du locataire (ACL)
</div>

Auth0 fournit une [ACL du locataire](/fr-CA/docs/secure/tenant-access-control-list) pour gérer le trafic vers le point de terminaison `/oidc/register`. Vous pouvez limiter qui peut envoyer des requêtes DCR en configurant des règles d’ACL en fonction des éléments suivants :

* Adresses IP sources et plages CIDR
* Géolocalisation
* Autres signaux de requête

Pour configurer des règles d’ACL pour DCR, ajoutez le scope `dcr` à une règle d’ACL. Pour en savoir plus, consultez la [référence de l’ACL du locataire](/fr-CA/docs/secure/tenant-access-control-list/reference).

<div id="rate-limits">
  ## Limites de débit
</div>

Le point de terminaison `/oidc/register` est soumis à une limite de 5 requêtes par seconde et par locataire. Pour en savoir plus sur les limites de débit, consultez [Configuration des limites de débit](/fr-CA/docs/troubleshoot/customer-support/operational-policies/rate-limit-policy/rate-limit-configurations).

<div id="permissive-mode-for-dcr">
  ## Mode permissif pour DCR
</div>

Certains clients qui utilisaient des applications tierces avant avril 2026 peuvent configurer DCR pour créer des applications avec le comportement existant plutôt qu’avec des contrôles de sécurité renforcés. Pour en savoir plus, consultez [Enregistrement dynamique des applications en mode permissif](/fr-CA/docs/get-started/applications/third-party-applications/permissive-mode#dynamic-client-registration-in-permissive-mode).

<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)
* [Accès des applications aux API : autorisations d’application](/fr-CA/docs/get-started/applications/application-access-to-apis-client-grants)
* [Applications propriétaires et applications tierces](/fr-CA/docs/get-started/applications/first-party-and-third-party-applications)
* [Consentement de l’utilisateur et applications tierces](/fr-CA/docs/get-started/applications/third-party-applications/user-consent-and-third-party-applications)