> ## 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 crear Rules con el Dashboard de Auth0 o la Management API.

# Crear Rules

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 (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 su fin de vida.

  Le recomendamos encarecidamente que use Actions para extender Auth0. Con Actions, tiene acceso a información de tipos más completa, documentación en línea y paquetes públicos de `npm`, y puede conectar integraciones externas que mejoran su experiencia general de extensibilidad. Para obtener más información sobre lo que ofrece Actions, lea [Comprender 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 de [Migrar a Actions](https://auth0.com/platform/extensibility/movetoactions) que destaca comparaciones de características, [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 deprecación de Rules y Hooks, lea nuestra entrada del blog: [Preparación para el fin de vida 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 obtener más información sobre cómo migrar sus Rules a Actions, lea [Migrar de Rules a Actions](/es/docs/customize/actions/migrate/migrate-from-rules-to-actions). Para obtener más información sobre cómo migrar sus Hooks a Actions, lea [Migrar de Hooks a Actions](/es/docs/customize/actions/migrate/migrate-from-hooks-to-actions).
</Warning>

Puede crear sus propias reglas para satisfacer sus requisitos específicos de funcionalidad. Puede modificar una plantilla de regla existente o empezar desde cero con uno de nuestros ejemplos. Auth0 proporciona varias reglas y plantillas de reglas existentes para ayudarle a alcanzar sus objetivos. Para ver una lista, visite nuestro[repositorio de reglas en GitHub](https://github.com/auth0/rules).

<div id="how-rules-work">
  ## Cómo funcionan las Rules
</div>

Las Rules son funciones de JavaScript que se ejecutan cuando un usuario se autentica en su aplicación. Se ejecutan una vez completado el proceso de autenticación, y puede usarlas para personalizar y ampliar las capacidades de Auth0. Por motivos de seguridad, el código de sus Rules se ejecuta de forma aislada del código de otros inquilinos de Auth0, en un entorno aislado. Las Rules también se ejecutan durante el flujo de actualización de tokens. Para obtener más información, consulte [Tokens de actualización](/es/docs/secure/tokens/refresh-tokens).

En Auth0, el flujo de transacción de autenticación funciona de la siguiente manera cuando usa Rules:

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2gtBtkPChIyguA24x6enx2/ffbb8e21e86920ef9914f6fc126dc1df/flow.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=5fe45045dde25176e6cb531d5a938e8e" alt="Diagrama de las Rules en el flujo de autenticación" width="2942" height="1062" data-path="docs/images/cdy7uua7fh8z/2gtBtkPChIyguA24x6enx2/ffbb8e21e86920ef9914f6fc126dc1df/flow.png" />
</Frame>

1. Una aplicación inicia una solicitud de autenticación a Auth0.
2. Auth0 enruta la solicitud a un proveedor de identidad mediante una conexión configurada.
3. El usuario se autentica correctamente.
4. El token de ID y/o el token de acceso pasan por el flujo de procesamiento de Rules y luego se envían a la aplicación.

<div id="prerequisite">
  ## Requisito previo
</div>

Si planea usar variables globales en su regla, asegúrese de configurar primero las variables de sus Rules. Para obtener más información, consulte [Configurar variables globales para Rules](/es/docs/customize/rules/configure-global-variables-for-rules).

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

1. Vaya a [Dashboard > Auth Pipeline > Rules](https://manage.auth0.com/#/rules) y haga clic en **Create**.

   <Frame>
     <img src="https://mintcdn.com/translations/pvjQqAy3EB2TK6NP/docs/images/cdy7uua7fh8z/4OiSXzc5fYgPagHdOGbfvj/a589bdf811df66658fe21c509aed610c/Dashboard_-_Auth_Pipeline_-_Rules.png?fit=max&auto=format&n=pvjQqAy3EB2TK6NP&q=85&s=fd0731ae46909908816273b82c2faa9e" alt="Dashboard - Auth Pipeline - Rules " width="1039" height="795" data-path="docs/images/cdy7uua7fh8z/4OiSXzc5fYgPagHdOGbfvj/a589bdf811df66658fe21c509aed610c/Dashboard_-_Auth_Pipeline_-_Rules.png" />
   </Frame>
2. Seleccione una plantilla de regla.

   <Frame>
     <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6IydSSjg2oQrdSzErcTYtN/d17348a98c597a74b2989c298764b9e1/dashboard-rules-create_choose-template.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=625ac84ff19fc0d38f2c3db41514ea01" alt="Dashboard - Auth Pipeline - Rules - Template" width="1502" height="1098" data-path="docs/images/cdy7uua7fh8z/6IydSSjg2oQrdSzErcTYtN/d17348a98c597a74b2989c298764b9e1/dashboard-rules-create_choose-template.png" />
   </Frame>
3. Asigne un nombre a la regla, modifique el script según sus necesidades y haga clic en **Save changes**.

   <Frame>
     <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/5CoC6cnazv2uT1iSq6OGsm/6cb30d9479971be771313da80acc4802/Dashboard_-_Auth_Pipeline_-_Rules_-_Edit_Rule.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=0abaef24f1d52ef0300cb360ee3cfa5d" alt="Dashboard - Auth Pipeline - Rules - Edit Rule" width="1103" height="1018" data-path="docs/images/cdy7uua7fh8z/5CoC6cnazv2uT1iSq6OGsm/6cb30d9479971be771313da80acc4802/Dashboard_-_Auth_Pipeline_-_Rules_-_Edit_Rule.png" />
   </Frame>

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

Realice una llamada `POST` al [endpoint Create Rule](https://auth0.com/docs/api/management/v2#!/Rules/post_rules). Asegúrese de reemplazar los valores de marcador de posición `MGMT_API_ACCESS_TOKEN`, `RULE_NAME`, `RULE_SCRIPT`, `RULE_ORDER` y `RULE_ENABLED` por los valores correspondientes de su <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> <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Access+Token">Token de acceso</Tooltip>, el nombre de la regla, el script de la regla, el número de orden de la regla y el valor de habilitación de la regla, respectivamente.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/rules' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/rules");
  var request = new RestRequest(Method.POST);
  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": "RULE_NAME", "script": "RULE_SCRIPT" }", 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/rules"

  	payload := strings.NewReader("{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }")

  	req, _ := http.NewRequest("POST", 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.post("https://{yourDomain}/api/v2/rules")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/rules',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {name: 'RULE_NAME', script: 'RULE_SCRIPT'}
  };

  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/rules",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }",
    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": "RULE_NAME", "script": "RULE_SCRIPT" }"

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

  conn.request("POST", "/{yourDomain}/api/v2/rules", 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/rules")

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

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

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

| Valor                     | Descripción                                                                                                                                                                                                                                                       |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MGMT_API_ACCESS_TOKEN`   | Token de acceso para la Management API con el scope `create:rules`.                                                                                                                                                                                               |
| `RULE_NAME`               | Nombre de la regla que desea crear. El nombre de la regla solo puede contener caracteres alfanuméricos, espacios y guiones; no puede comenzar ni terminar con espacios ni guiones.                                                                                |
| `RULE_SCRIPT`             | Script que contiene el código de la regla. Debe coincidir con lo que introduciría si creara una regla nueva desde el Dashboard.                                                                                                                                   |
| `RULE_ORDER` (opcional)   | Entero que representa el orden en que debe ejecutarse la regla con respecto a otras reglas. Las reglas con números más bajos se ejecutan antes que las reglas con números más altos. Si no se proporciona ningún número de orden, la regla se ejecutará al final. |
| `RULE_ENABLED` (opcional) | Booleano que indica si la regla está habilitada (`true`) o deshabilitada (`false`).                                                                                                                                                                               |

<Warning>
  Exponemos direcciones IPv6 en nuestros endpoints públicos (por ejemplo, `travel0.us.auth0.com`). Si una solicitud llega desde una máquina compatible con IPv6, la propiedad `context.request.ip` contendrá una dirección IPv6. Si realiza una manipulación manual de direcciones IP, le sugerimos usar la [biblioteca ipaddr.js@1.9.0](https://www.npmjs.com/package/ipaddr.js/v/1.9.0).
</Warning>

<div id="manage-rate-limits">
  ## Gestionar los límites de tasa
</div>

Para las Rules que llaman a las API de Auth0, siempre debe gestionar la limitación de tasa comprobando el encabezado `X-RateLimit-Remaining` y actuando según corresponda cuando el valor devuelto se aproxime a 0. También debe añadir lógica para gestionar los casos en los que supere los límites de tasa establecidos y reciba el código de estado HTTP 429 (Too Many Requests); en este caso, si es necesario reintentar, lo mejor es aplicar una espera progresiva para evitar entrar en un bucle infinito de reintentos. Para obtener más información sobre los límites de tasa, consulte [Política de límites de tasa para las API de Auth0](/es/docs/troubleshoot/customer-support/operational-policies/rate-limit-policy).

<div id="available-modules">
  ## Módulos disponibles
</div>

Rules se ejecutan en un entorno aislado de JavaScript configurado para una versión específica de Node.js.

El entorno aislado admite todas las versiones del lenguaje JavaScript (y la sintaxis asociada) de la versión configurada de Node.js, así como una gran cantidad de módulos de Node.js. Para obtener una lista de los módulos compatibles del entorno aislado, consulta [Can I require: Auth0 Extensibility](https://auth0-extensions.github.io/canirequire/).

<div id="learn-more">
  ## Más información
</div>

* [Configurar las variables globales para Rules](/es/docs/customize/rules/configure-global-variables-for-rules)