> ## 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 mettre à jour les Hooks à l’aide du Dashboard ou de la Management API. Les Hooks peuvent aussi être importés et exportés à l’aide de l’outil Auth0 Deploy Command-Line Interface (CLI).

# Mettre à jour les Hooks

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

<Warning>
  La date de fin de vie (EOL) de Rules et Hooks sera le **18 novembre 2026**, et ils ne sont plus offerts aux nouveaux tenants créés à compter du **16 octobre 2023**. Les tenants existants ayant des Hooks actifs conserveront l’accès au produit Hooks jusqu’à la fin de vie.

  Nous vous recommandons fortement d’utiliser Actions pour étendre Auth0. Avec Actions, vous avez accès à des informations de typage détaillées, à de la documentation intégrée et à des packages `npm` publics, et vous pouvez connecter des intégrations externes qui améliorent votre expérience globale d’extensibilité. Pour en savoir plus sur ce qu’offrent Actions, consultez [Comprendre le fonctionnement des Auth0 Actions](/docs/fr-ca/customize/actions/actions-overview).

  Pour vous aider dans votre migration, nous proposons des guides pour vous aider à [passer de Rules à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-rules-to-actions) et à [passer de Hooks à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-hooks-to-actions). Nous avons aussi une page dédiée, [Passer à Actions](https://auth0.com/extensibility/movetoactions), qui présente des comparaisons de fonctionnalités, [une démonstration d’Actions](https://www.youtube.com/watch?v=UesFSY1klrI) et d’autres ressources pour vous accompagner dans votre migration.

  Pour en savoir plus sur la dépréciation de Rules et Hooks, consultez notre billet de blogue : [Preparing for Rules and Hooks End of Life](https://auth0.com/blog/preparing-for-rules-and-hooks-end-of-life/).
</Warning>

<Warning>
  Comme nous prévoyons retirer les fonctions Rules et Hooks en 2026, vous ne devriez créer de nouvelles Rules ou de nouveaux Hooks que dans votre environnement de développement, et uniquement pour tester la migration vers Actions.

  Pour savoir comment migrer vos Rules vers Actions, consultez [Passer de Rules à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-rules-to-actions). Pour savoir comment migrer vos Hooks vers Actions, consultez [Passer de Hooks à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-hooks-to-actions).
</Warning>

Vous pouvez mettre à jour les Hooks à l’aide du Dashboard ou de <Tooltip tip="Management API : un produit permettant aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip>.

Vous pouvez aussi importer et exporter des Hooks à l’aide de l’[outil Deploy Command-Line Interface (CLI)](/docs/fr-ca/deploy-monitor/deploy-cli-tool).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Au besoin, vous pouvez ajouter des secrets (comme des clés Twilio ou des chaînes de connexion à la base de données) aux Hooks.
</Callout>

<div id="rename-hooks-using-the-dashboard">
  ## Renommer des hooks dans le Dashboard
</div>

1. Accédez à [Auth0 Dashboard > Auth Pipeline > Hooks](https://manage.auth0.com/#/) et cliquez sur l’icône d’engrenage à côté du hook que vous souhaitez renommer.
2. Cliquez sur **Rename**.
3. Entrez un nouveau nom pour le Hook, puis cliquez sur **Rename**.

   <Frame>
     <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2Xp8Z3uYGoGZrF5EGXLPLQ/6c68c77f97133b2066219a68540b1e73/Screen_Shot_2021-05-19_at_12.08.00_PM.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=9cab96b502d7e1f8922295d577f218d4" alt="Auth0 Renommer des Hooks" width="1270" height="518" data-path="docs/images/cdy7uua7fh8z/2Xp8Z3uYGoGZrF5EGXLPLQ/6c68c77f97133b2066219a68540b1e73/Screen_Shot_2021-05-19_at_12.08.00_PM.png" />
   </Frame>

<div id="update-hook-scripts-using-the-dashboard">
  ## Mettre à jour les scripts de hook dans le Dashboard
</div>

1. Accédez à [Auth0 Dashboard > Auth Pipeline > Hooks](https://manage.auth0.com/#/) et cliquez sur l’icône en forme de crayon à côté du hook que vous souhaitez mettre à jour.

   <Frame>
     <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2y2R713TkAvQWIMZPMd1zh/bf0a657261f2d090492660ea5962e0a3/dashboard-hooks-list.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=7ae4b246c15b040cd8a797335ded45e1" alt="Auth0 Hooks : sélectionner un Hook" width="1502" height="933" data-path="docs/images/cdy7uua7fh8z/2y2R713TkAvQWIMZPMd1zh/bf0a657261f2d090492660ea5962e0a3/dashboard-hooks-list.png" />
   </Frame>
2. Mettez à jour le hook à l’aide du Hook Editor, puis cliquez sur l’icône de disquette pour enregistrer.

   <Frame>
     <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/26u71QdXxZxg5zIH8SJQAg/e9bbd25b99d9b8fd44c281b6de83a5a3/dashboard-hooks-edit_menu.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=87a2a2fcec77b30380d999d4c904d053" alt="Auth0 Hook Editor" width="1502" height="1193" data-path="docs/images/cdy7uua7fh8z/26u71QdXxZxg5zIH8SJQAg/e9bbd25b99d9b8fd44c281b6de83a5a3/dashboard-hooks-edit_menu.png" />
   </Frame>

<div id="update-hooks-using-the-management-api">
  ## Mettre à jour les hooks à l’aide de la Management API
</div>

Effectuez une requête `PATCH` au [point de terminaison Mettre à jour un Hook](https://auth0.com/docs/api/management/v2/#!/Hooks/patch_hooks_by_id). Assurez-vous de remplacer les valeurs de l’espace réservé `HOOK_ID` et `MGMT_API_ACCESS_TOKEN` par votre ID de Hook et votre <Tooltip tip="Jeton d’accès : information d’identification dans l’en-tête Authorization, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip> de la Management API, respectivement.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/hooks/HOOK_ID' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/hooks/HOOK_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{yourDomain}/api/v2/hooks/HOOK_ID"

  	payload := strings.NewReader("{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }")

  	req, _ := http.NewRequest("PATCH", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	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<String> response = Unirest.patch("https://{yourDomain}/api/v2/hooks/HOOK_ID")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/hooks/HOOK_ID',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {name: 'HOOK_NAME', script: 'HOOK_SCRIPT', enabled: 'true'}
  };

  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://{yourDomain}/api/v2/hooks/HOOK_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "content-type: application/json"
    ],
  ]);

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

  payload = "{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/hooks/HOOK_ID", payload, 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://{yourDomain}/api/v2/hooks/HOOK_ID")

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

  request = Net::HTTP::Patch.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "name": "HOOK_NAME", "script": "HOOK_SCRIPT", "enabled": "true" }"

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

| Valeur                  | Description                                                                                                                                                                                                            |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HOOK_ID`               | ID du Hook à mettre à jour.                                                                                                                                                                                            |
| `MGMT_API_ACCESS_TOKEN` | Jetons d’accès pour la Management API avec le [scope](/docs/fr-ca/glossary?term=scope) `update:hooks`. Pour en savoir plus, consultez [Management API Access Tokens](https://auth0.com/docs/api/management/v2/tokens). |
| `HOOK_NAME`             | Nom du Hook à créer.                                                                                                                                                                                                   |
| `HOOK_SCRIPT`           | Script qui contient le code du Hook. Il doit correspondre à ce que vous saisiriez si vous créiez un nouveau Hook dans le Dashboard.                                                                                    |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propriété `enabled` indique si la règle est activée (`true`) ou désactivée (`false`).
</Callout>

<Card title="Gérer les limites de débit lors de l’appel d’API depuis des Hooks">
  Si vous envoyez des requêtes à des API Auth0 à partir du script d’un Hook, vous devrez gérer les limites de débit. Pour ce faire, vérifiez l’en-tête `X-RateLimit-Remaining` et réagissez de façon appropriée lorsque le nombre retourné approche de 0.

  De plus, ajoutez une logique pour gérer les cas où vous dépassez les limites de débit fournies et recevez le code d’état HTTP `429` (`Too Many Requests`). Dans ce cas, si une nouvelle tentative est nécessaire, il est préférable de prévoir une temporisation progressive afin d’éviter une boucle infinie de tentatives.
</Card>