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

> Aprenda a habilitar y deshabilitar Hooks mediante el Dashboard y la Management API.

# Habilitar/deshabilitar 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) + "*****ENMASCARADO*****";
          }
          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 fecha de fin de vida útil (EOL) de Rules y Hooks será el **18 de noviembre de 2026**, y ya no están disponibles para nuevos inquilinos creados a partir del **16 de octubre de 2023**. Los inquilinos existentes con Hooks activos conservarán el acceso al producto Hooks hasta el fin de vida útil.

  Le recomendamos encarecidamente que use Actions para ampliar Auth0. Con Actions, tiene acceso a información de tipos detallada, documentación integrada y paquetes `npm` públicos, y puede conectar integraciones externas que mejoran su experiencia general de extensibilidad. Para obtener más información sobre lo que ofrece Actions, lea [Cómo funcionan las Actions de Auth0](/es/docs/customize/actions/actions-overview).

  Para ayudarle con la migración, ofrecemos guías que le ayudarán a [migrar de Rules a Actions](/es/docs/customize/actions/migrate/migrate-from-rules-to-actions) y [migrar de Hooks a Actions](/es/docs/customize/actions/migrate/migrate-from-hooks-to-actions). También contamos con una página dedicada, [Move to Actions](https://auth0.com/extensibility/movetoactions), que destaca comparaciones de funciones, [una demostración de Actions](https://www.youtube.com/watch?v=UesFSY1klrI) y otros recursos para ayudarle durante el proceso de migración.

  Para obtener más información sobre la retirada de Rules y Hooks, lea nuestra entrada del blog: [Preparación para el fin de vida útil de Rules y Hooks](https://auth0.com/blog/preparing-for-rules-and-hooks-end-of-life/).
</Warning>

<Warning>
  Como tenemos previsto eliminar las funciones de Rules y Hooks en 2026, debe crear nuevas Rules o Hooks solo en su entorno de desarrollo y únicamente para probar la migración a Actions.

  Para aprender a migrar sus Rules a Actions, lea [Migrar de Rules a Actions](/es/docs/customize/actions/migrate/migrate-from-rules-to-actions). Para aprender a migrar sus Hooks a Actions, lea [Migrar de Hooks a Actions](/es/docs/customize/actions/migrate/migrate-from-hooks-to-actions).
</Warning>

Puede habilitar o deshabilitar hooks mediante el Dashboard o la <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip>.

<Warning>
  Aunque puede crear varios hooks para un punto de extensibilidad determinado, cada punto de extensibilidad solo puede tener un hook habilitado a la vez. Los hooks posteriores que cree para ese punto de extensibilidad se deshabilitarán automáticamente, por lo que deberá habilitarlos explícitamente. El hook habilitado se ejecutará para todas las aplicaciones y APIs.
</Warning>

<Warning>
  Al crear nuevos hooks, Auth0 habilita automáticamente el primer Hook que cree para un punto de extensibilidad. Los hooks posteriores que cree para ese punto de extensibilidad se deshabilitarán automáticamente, por lo que deberá habilitarlos explícitamente.
</Warning>

<div id="use-the-dashboard">
  ## Use el Dashboard
</div>

1. Vaya a [Auth0 Dashboard > Auth Pipeline > Hooks](https://manage.auth0.com/#/) y localice el punto de extensibilidad para el que desea habilitar o deshabilitar un Hook.
2. Haga clic en el menú desplegable situado justo debajo del nombre y la descripción del punto de extensibilidad.

   <Frame>
     <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2LCBPLtrsjmmJYxCGfWquT/74b232fd96aa179c89f01e46d2e91ce3/dashboard-hooks-list.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=6a30ad4a7f9af7f9a36a25e9193fc87f" alt="Selección de Hooks de Auth0" width="1502" height="933" data-path="docs/images/cdy7uua7fh8z/2LCBPLtrsjmmJYxCGfWquT/74b232fd96aa179c89f01e46d2e91ce3/dashboard-hooks-list.png" />
   </Frame>
3. Seleccione el Hook que desea habilitar y confirme. Si desea deshabilitar todos los Hooks, seleccione `None`.

Aparecerá un punto verde junto al nombre de cualquier Hook habilitado.

<div id="use-the-management-api">
  ## Utilice la Management API
</div>

Haga una llamada `PATCH` al endpoint [Update a Hook](https://auth0.com/docs/api/management/v2/#!/Hooks/patch_hooks_by_id). Asegúrese de reemplazar los valores de marcador de posición `HOOK_ID` y `MGMT_API_ACCESS_TOKEN` por el ID de su Hook y el <Tooltip tip="Token de acceso: Credencial de autorización, en forma de una cadena opaca o JWT, utilizada para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">Token de acceso</Tooltip> de la Management API, respectivamente.

<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 '{ "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", "{ "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("{ "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("{ "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: {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 => "{ "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 = "{ "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_NONE

  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 = "{ "enabled": "true" }"

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

| Valor                   | Descripción                                                                                                                                                                                                                        |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HOOK_ID`               | ID del hook que se va a actualizar.                                                                                                                                                                                                |
| `MGMT_API_ACCESS_TOKEN` | Token de acceso de la Management API con el [scope](/es/docs/glossary?term=scope) `create:hooks`. Para obtener más información, consulte [Tokens de acceso de la Management API](https://auth0.com/docs/api/management/v2/tokens). |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La propiedad `enabled` indica si la Rule está habilitada (`true`) o deshabilitada (`false`).
</Callout>