> ## 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 enregistrer dynamiquement des applications tierces dans Auth0.

# Enregistrement dynamique des clients

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

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

Toutes les applications créées par Dynamic Client Registration sont des [applications tierces](/docs/fr-ca/get-started/applications/third-party-applications) assorties de [contrôles de sécurité renforcés](/docs/fr-ca/get-started/applications/third-party-applications/security-controls). Cela signifie que les clients DCR :

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

<div id="enable-dynamic-client-registration">
  ## Activer Dynamic Client Registration
</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 tenant sans jeton.
</Warning>

Par défaut, Dynamic Client Registration est désactivé pour tous les tenants. Pour activer Dynamic Client Registration, utilisez l’Auth0 Dashboard ou la Management API.

<Tabs>
  <Tab title="Auth0 Dashboard">
    1. Accédez à [Dashboard > Paramètres > Avancé](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 tenant à 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 [Management API Access Tokens](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens).
  </Tab>
</Tabs>

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

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

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

Pour savoir comment configurer les autorisations par défaut, consultez [Configurer les applications tierces](/docs/fr-ca/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 Open Dynamic Registration, 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` (obligatoire) | Un tableau d’URL qu’Auth0 acceptera comme URL de rappel 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 clients publics (SPA, Native) ou `client_secret_post` (par défaut) pour les clients confidentiels.                                                                |
| `grant_types`                 | Les types d’octroi que l’application souhaite utiliser. Dans la réponse, ils sont filtrés pour ne refléter que 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.                                                                                                                                                     |

En cas de réussite, 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 les flux d’authentification.                  |
| `client_secret`            | Secret client de l’application pour les clients confidentiels. N’est pas renvoyé lorsque `token_endpoint_auth_method` est `none`. |
| `client_secret_expires_at` | Date 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 contacter le propriétaire du tenant.
</Callout>

Après l’enregistrement, l’application peut lancer un [Flux de code d’autorisation avec PKCE](/docs/fr-ca/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">
  ## Tenant Access Control List (ACL)
</div>

Auth0 fournit une [Tenant Access Control List (ACL)](/docs/fr-ca/secure/tenant-access-control-list) pour gérer le trafic vers le point de terminaison `/oidc/register`. Vous pouvez limiter les personnes autorisées à envoyer des requêtes DCR en configurant des règles d’ACL selon :

* Les adresses IP source et les plages CIDR
* La géolocalisation
* D’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 Tenant ACL](/docs/fr-ca/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 par tenant. Pour en savoir plus sur les limites de débit, consultez [Configuration de la limite de débit](/docs/fr-ca/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 préexistant plutôt qu’avec des mesures de sécurité renforcées. Pour en savoir plus, consultez [Dynamic Client Registration en mode permissif](/docs/fr-ca/get-started/applications/third-party-applications/permissive-mode#dynamic-client-registration-in-permissive-mode).

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

* [Applications tierces](/docs/fr-ca/get-started/applications/third-party-applications)
* [Mesures de sécurité pour les applications tierces](/docs/fr-ca/get-started/applications/third-party-applications/security-controls)
* [Accès des applications aux API : autorisations client](/docs/fr-ca/get-started/applications/application-access-to-apis-client-grants)
* [Applications propriétaires et tierces](/docs/fr-ca/get-started/applications/first-party-and-third-party-applications)
* [Consentement de l’utilisateur et applications tierces](/docs/fr-ca/get-started/applications/third-party-applications/user-consent-and-third-party-applications)