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

> Describe cómo empezar a usar un caso de uso empresarial de M2M.

# Máquina a máquina de autoservicio

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

Si su caso de uso atiende a una <Tooltip tip="Audiencia: identificador único de la audiencia de un token emitido. Se denomina aud en un token; su valor contiene el ID de una aplicación (ID de cliente) para un ID Token o de una API (identificador de API) para un Token de acceso." cta="Ver glosario" href="/es/docs/glossary?term=audience">audiencia</Tooltip> no interactiva, como las API o los servidores backend, la incorporación se realizará con una configuración de máquina a máquina (M2M).

<div id="use-cases">
  ## Casos de uso
</div>

Use el flujo de incorporación M2M si:

* Admite comunicaciones de servicio a servicio
* Tiene trabajos programados o tareas cron en servidores que necesitan acceder a recursos protegidos o APIs
* Permite que dispositivos IoT se comuniquen con servicios de backend o APIs
* Tiene una capa de API que necesita comunicarse con otras capas de API sin intervención del usuario o después de que haya expirado un token de usuario
* Tiene una API privilegiada que puede necesitar invocarse antes de que un usuario se haya autenticado (es decir, desde una Action o un script personalizado de base de datos en su inquilino de Auth0)
* Usa un API Gateway para administrar servicios de backend
* Usa o admite aplicaciones no interactivas u otras herramientas que no implican interacción humana, como demonios o servicios de backend

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Estos servicios seguirán necesitando un token de acceso M2M para autenticarse.
</Callout>

<div id="how-to-use-this-guide">
  ## Cómo usar esta guía
</div>

Esta guía le sirve de referencia para crear su implementación M2M en Auth0. Incluye consideraciones, prácticas recomendadas y conceptos que debería revisar.

* En Arquitectura, le recomendamos configurar Auth0 para que sea compatible con su ciclo de vida de desarrollo de software y con su infraestructura existente.
* En Crear una cuenta, encontrará instrucciones para crear su instancia de API en Auth0 y una aplicación que admita el flujo de autenticación (o grant) necesario para la autenticación de máquina a máquina.
* En Autenticación, explicamos el grant que debe usar para la autenticación, así como los <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+tokens">tokens de acceso</Tooltip> y permisos (o alcances) que puede configurar.
* En Marca, le indicamos dónde encontrar información sobre cómo configurar <Tooltip tip="Dominio personalizado: Dominio de terceros con un nombre especializado o personalizado." cta="Ver glosario" href="/es/docs/glossary?term=Custom+Domains">dominios personalizados</Tooltip> según cómo planee administrar los certificados.
* En Automatizaciones de implementación, puede consultar nuestras herramientas para facilitar la implementación.
* En Garantía de calidad, puede obtener más información sobre las pruebas unitarias y las comprobaciones de preparación que ofrecemos en <Tooltip tip="Auth0 Dashboard: El producto principal de Auth0 para configurar sus servicios." cta="Ver glosario" href="/es/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>.

<div id="architecture">
  ## Arquitectura
</div>

Antes de configurar su cuenta y el inquilino de Auth0, o los grupos y estructuras de sus servicios de Auth0, cree un mapa de su infraestructura existente para poder aprovechar al máximo las capacidades de Auth0 en su ecosistema actual.

Como se menciona en los escenarios comunes, es posible que tenga otras tecnologías no interactivas en el dominio de su aplicación, el dominio de red o el dominio de dispositivos M2M que deba considerar antes de configurar Auth0. Para consultar un ejemplo de escenario M2M, lea [Server + API](/es/docs/get-started/architecture-scenarios/server-application-api/part-1). Para realizar un laboratorio práctico con Node y probar la implementación de API, visite nuestro [repositorio de GitHub](https://www.google.com/url?q=https://github.com/auth0-training/labs-node-working-with-apis\&sa=D\&source=docs\&ust=1723578190947730\&usg=AOvVaw3IXRQG9ogH4pW6LEY047T6).

También puede resultarle útil crear una visualización de su stack tecnológico actual, así como planificar cómo encaja Auth0 en su ciclo de vida actual de desarrollo de software (SDLC). Esto puede ayudarle a determinar cuántos inquilinos podría necesitar.

<div id="considerations">
  ### Consideraciones
</div>

Antes de crear una cuenta nueva o configurar tu primer inquilino, quizá quieras tener en cuenta lo siguiente:

* Cómo divides o agrupas tus API para llamar a endpoints específicos.

  * Esto puede determinar la audiencia y otros claims de los tokens de acceso.
* Cualquier consumidor externo de tu recurso puede solicitar un token de acceso en cada llamada. Un volumen excesivo de solicitudes podría afectar tu [límite de tasa](/es/docs/troubleshoot/customer-support/operational-policies/rate-limit-policy/rate-limit-configurations/essentials-professional-b2b).

  * Puedes usar un API Gateway para limitar la cantidad de tokens de acceso que un tercero puede solicitar. Para obtener más información sobre API Gateways y Auth0, consulta [Configurar un Proveedor de identidad en Access Gateway](/es/docs/get-started/auth0-overview/create-applications/configure-an-identity-provider-in-access-gateway).

<div id="create-an-account">
  ## Crear una cuenta
</div>

Ahora que ya tiene un plan para su arquitectura, configurará su cuenta y sus inquilinos de Auth0. Cuando se registre en los servicios de Auth0, creará su primer [inquilino](/es/docs/get-started/auth0-overview/create-tenants). Aquí es donde configurará los recursos, servicios y demás elementos de Auth0. [Regístrese](https://auth0.com/signup) para comenzar.

<Card title="Antes de comenzar">
  En el Auth0 Dashboard o mediante Auth0 Management API, cree:

  * Una API para representar su API
  * Una aplicación M2M para usar el flujo de credenciales del cliente

  Quizás le convenga planificar algunos detalles de configuración antes de crear una cuenta.

  * El nombre de su inquilino influye en su dominio de Auth0. Antes de decidirlo, debería revisar las [características del inquilino](/es/docs/get-started/auth0-overview/create-tenants#create-a-tenant-and-domain).
  * Qué características de Auth0 necesita para su caso de uso. Algunas solo están disponibles en los planes Professional y Enterprise.
  * Determine si necesita admitir varios entornos, como desarrollo, preproducción y producción. Para obtener más información, consulte [Configurar varios entornos](/es/docs/get-started/auth0-overview/create-tenants/set-up-multiple-environments).
  * Si tiene un caso de uso que involucra aplicaciones de terceros que desea registrar en un inquilino, puede usar [Dynamic Application Registration](/es/docs/get-started/applications/dynamic-client-registration) según la especificación [OIDC Client Registration](https://openid.net/specs/openid-connect-registration-1_0.html).
</Card>

<div id="provision-a-tenant">
  ### Aprovisionar un inquilino
</div>

Ahora que ya tiene un plan para su arquitectura, configurará su cuenta de Auth0 y su <Tooltip tip="Tenant: En Auth0, un grupo de usuarios aislado lógicamente que comparte un acceso común con privilegios específicos sobre una única instancia de software. Ningún inquilino puede acceder a los datos de otro inquilino, aunque varios inquilinos puedan ejecutarse en la misma máquina." cta="Ver glosario" href="/es/docs/glossary?term=Tenant">Tenant</Tooltip>.

<Warning>
  Una vez que cree una API en Auth0 Dashboard, se generará automáticamente una aplicación de prueba para la API. Si crea una API mediante programación con [Management API](https://auth0.com/docs/api/management/v2/), es posible que deba crear una aplicación de prueba en una llamada aparte.
</Warning>

<div id="register-an-api">
  #### Registrar una API
</div>

En esta sección, cree su API en Auth0.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Siempre puede actualizar su API en Auth0 Dashboard o mediante el endpoint de Management API [Update a resource server](https://auth0.com/docs/api/management/v2/resource-servers/patch-resource-servers-by-id).
</Callout>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Empiece creando una instancia en Auth0 Dashboard para sus API.

    1. Siga las instrucciones para [registrar su API](/es/docs/get-started/auth0-overview/set-up-apis).

    En la sección [Authentication](/es/docs/get-started/onboarding/self-service-m2m#authentication), configure los ajustes de su API para la autenticación M2M.
  </Tab>

  <Tab title="Management API">
    Para registrar una API de forma programática, use Management API. Necesitará un token de acceso para usar Management API. Para saber cómo obtenerlo, consulte [Management API Tokens](/es/docs/secure/tokens/access-tokens/management-api-access-tokens).

    Use el ejemplo proporcionado en Management API Explorer para llamar al endpoint de Management API [Create a Resource Server](https://auth0.com/docs/api/management/v2/resource-servers/post-resource-servers) e incluya los siguientes parámetros en el cuerpo:

    | Campo                                          | Descripción                                                                                                                                                                                                                                                                                                                                                   | Ejemplo                |
    | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
    | **Nombre**                                     | Un nombre descriptivo para la API. No afecta a ninguna funcionalidad.                                                                                                                                                                                                                                                                                         | `yourDomain`           |
    | **Identificador**                              | Un identificador único para la API. Auth0 recomienda usar una URL. Auth0 distingue entre las URL que incluyen la barra diagonal final. Por ejemplo, `https://example.com` y `https://example.com/` son dos identificadores distintos. La URL no tiene que estar disponible públicamente. Auth0 no llamará a su API. Este valor no se puede modificar después. | `https://{yourDomain}` |
    | **Perfil de JSON Web Token (JWT)**             | El perfil determina el formato de los tokens de acceso emitidos para la API. Los valores disponibles son `Auth0` y `RFC 9068`. Para obtener más información, consulte [Access Token Profiles](/es/docs/secure/tokens/access-tokens/access-token-profiles).                                                                                                    | `access_token`         |
    | **Algoritmo de firma de JSON Web Token (JWT)** | El algoritmo con el que se firman los tokens de acceso. Los valores disponibles son `HS256`, `PS256`, `RS256`. Si selecciona `RS256`, el token se firmará con la clave privada del inquilino.                                                                                                                                                                 | `HS256`                |
  </Tab>
</Tabs>

<div id="associate-an-application">
  ### Asociar una aplicación
</div>

Debe crear una asociación entre su aplicación y su API para que su aplicación pueda solicitar tokens de acceso a esta. Obtendrá más información sobre los client grants en la sección de Authentication.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La API de Auth0 tiene varios ajustes que quizá deba revisar antes de configurarla. Para obtener más información, lea [Configuración de la API](/es/docs/get-started/apis/api-settings).
</Callout>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Si crea su API en el Dashboard, Auth0 genera automáticamente una aplicación de prueba y la asocia con su API.

    1. Vaya a [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications).
    2. Seleccione la aplicación de prueba M2M que se creó al crear su API.

           <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
             Más adelante, puede crear otra aplicación para desarrollo o producción siguiendo las instrucciones de [Registrar aplicaciones de máquina a máquina](/es/docs/get-started/auth0-overview/create-applications/machine-to-machine-apps).
           </Callout>
    3. Cambie a la vista **API** y, a continuación, busque la API que desea habilitar para esta aplicación.
    4. Active el conmutador **Authorize** y, a continuación, seleccione el botón de flecha de la derecha para expandir la tarjeta.
    5. Seleccione **Update**.

           <Frame>
             <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5dcceb517182aeb823127810b9d37eeb" alt="Dashboard > Applications > APIs" data-og-width="1002" width="1002" data-og-height="979" height="979" data-path="docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=280&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5bdacc9d22696263d397995f3e290bc7 280w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=560&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=88c60c9895adeabea77c680acd91ace3 560w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=840&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=fed5de9446f4d1e1031cb01f579915fe 840w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=1100&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=1cb844cebe0c5e46915e034f0536893e 1100w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=1650&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=654deb2045141c2e7ab907c33593e5e2 1650w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=2500&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=84feca666adfd7e9fb5e153bfba1b504 2500w" />
           </Frame>

           <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
             En esta vista, puede seleccionar el menú desplegable y elegir los alcances que desea agregar. Obtendrá más información sobre los alcances al hablar de los tokens de acceso en la sección de Authentication.
           </Callout>
  </Tab>

  <Tab title="Management API">
    Cree una aplicación para asociarla con su API. Use el ejemplo proporcionado en Management API Explorer para hacer lo siguiente:

    1. Llame al endpoint [Create a Client](https://auth0.com/docs/api/management/v2/clients/post-clients). Debe establecer `app_type` en `non-interactive`.
    2. Llame al endpoint [Create Client Grant](https://auth0.com/docs/api/management/v2/client-grants/post-client-grants) para asociar su aplicación con su API.

    Para obtener información sobre la configuración de la aplicación y del inquilino, lea [Configuración del inquilino](/es/docs/get-started/tenant-settings).
  </Tab>
</Tabs>

<div id="authentication">
  ## Autenticación
</div>

Al llamar a una API desde otra API, o en cualquier situación en la que no haya un contexto de usuario autenticado, necesita una forma de autorizar a la aplicación en lugar de a un usuario. Este es un proceso de un solo paso en el que la aplicación se autentica (mediante un `client_id` y un `client_secret`) y luego se autoriza en una sola llamada.

Para autenticar aplicaciones o servicios no interactivos, debe seleccionar un client grant, o flujo de autenticación. El <Tooltip tip="OAuth 2.0: Marco de autorización que define protocolos y flujos de trabajo de autorización." cta="Ver glosario" href="/es/docs/glossary?term=OAuth+2.0">OAuth 2.0</Tooltip> [Client Credentials Flow](https://tools.ietf.org/html/rfc6749#section-4.4) no requiere interacción humana y es el más adecuado para aplicaciones M2M.

<Card title="Antes de comenzar">
  En Auth0 Dashboard o Management API, deberá hacer lo siguiente:

  * Configurar su aplicación para usar el flujo de credenciales del cliente
  * Actualizar los alcances de sus tokens de acceso M2M

  Antes de configurar su método de autenticación:

  * Revise el [Client Credentials Flow](/es/docs/get-started/authentication-and-authorization-flow/client-credentials-flow) para la autenticación de máquina a máquina. Este es el flujo de trabajo para la autenticación y autorización no interactivas.
  * Determine el nivel de acceso de sus API. Esto ayuda a determinar qué [alcances](/es/docs/get-started/apis/scopes/api-scopes), o permisos, configurará cuando cree su API.
</Card>

<div id="configure-the-client-credential-flow">
  ### Configurar el flujo de credenciales del cliente
</div>

Puede usar Auth0 Dashboard o <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> para configurar el flujo de autenticación de modo que proporcione credenciales de cliente a cambio de un token de acceso.

Siga las instrucciones de [Actualizar los tipos de concesión](/es/docs/get-started/applications/update-grant-types) para usar Auth0 Dashboard o Management API.

<div id="m2m-access-tokens">
  ### Tokens de acceso M2M
</div>

En la autenticación basada en tokens, los clientes no interactivos proporcionan `client_id` y `client_secret` en una llamada al [endpoint de token de Authentication API](/es/docs/customize/actions/explore-triggers/machine-to-machine-trigger) para obtener un [token de acceso](/es/docs/secure/tokens/access-tokens). Este token de acceso permite acceder a su API protegida.

El perfil, o formato, predeterminado es el perfil de token de Auth0, asociado a dos perfiles de token. Puede optar por cambiar el perfil de token a RFC 9068. Para obtener más información, consulte [Perfiles de token de acceso](/es/docs/secure/tokens/access-tokens/access-token-profiles). Para verificar que el token sea válido, su API comprobará los [algoritmos de firma](/es/docs/get-started/applications/signing-algorithms). El <Tooltip tip="Algoritmo de firma: algoritmo usado para firmar digitalmente tokens y garantizar que el token no haya sido manipulado." cta="Ver glosario" href="/es/docs/glossary?term=signing+algorithm">algoritmo de firma</Tooltip> predeterminado es RSA256, un algoritmo basado en claves.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Auth0 admite otros métodos de autenticación de cliente además de proporcionar ID de cliente y Secreto del cliente como credenciales. Estos métodos, incluida nuestra recomendación de [Private Key JWT](/es/docs/get-started/authentication-and-authorization-flow/authenticate-with-private-key-jwt) para configuraciones M2M, están disponibles con un plan Enterprise. Para obtener más información, consulte [Credenciales de aplicación](/es/docs/secure/application-credentials).
</Callout>

<div id="example">
  #### Ejemplo
</div>

Una solicitud al endpoint `/oauth/token` debe ser similar al ejemplo siguiente:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oauth/token' \
    --header 'content-type: application/x-www-form-urlencoded' \
    --data grant_type=client_credentials \
    --data client_id={yourClientId} \
    --data client_secret={yourClientSecret} \
    --data audience=YOUR_API_IDENTIFIER
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/token");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/x-www-form-urlencoded");
  request.AddParameter("application/x-www-form-urlencoded", "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER", 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}/oauth/token"

  	payload := strings.NewReader("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")

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

  	req.Header.Add("content-type", "application/x-www-form-urlencoded")

  	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 response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {'content-type': 'application/x-www-form-urlencoded'},
    data: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: '{yourClientId}',
      client_secret: '{yourClientSecret}',
      audience: 'YOUR_API_IDENTIFIER'
    })
  };

  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}/oauth/token",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER",
    CURLOPT_HTTPHEADER => [
      "content-type: application/x-www-form-urlencoded"
    ],
  ]);

  $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 = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

  headers = { 'content-type': "application/x-www-form-urlencoded" }

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

  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/x-www-form-urlencoded'
  request.body = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

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

La respuesta debe ser similar al ejemplo siguiente:

```json lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
  "access_token":"eyJz93a...k4laUWw",
  "token_type":"Bearer",
  "expires_in":86400
}
```

<div id="token-expiration">
  #### Expiración del token
</div>

Tus tokens de acceso tienen un límite de validez. Dado que tus comunicaciones se realizan por el canal de servidor a servidor, no puedes usar <Tooltip tip="Token de actualización: token que se usa para obtener un Token de acceso renovado sin obligar a los usuarios a volver a iniciar sesión." cta="Ver glosario" href="/es/docs/glossary?term=refresh+tokens">tokens de actualización</Tooltip> para extender las sesiones, por lo que deberías considerar configurar tus tokens de acceso con un tiempo de expiración de 1 hora. Puede que necesites encontrar un equilibrio entre seguridad y rendimiento para tu entorno específico. Para obtener más información, consulta [Update Access Token Lifetime](/es/docs/secure/tokens/access-tokens/update-access-token-lifetime).

<div id="scopes">
  ### Scopes
</div>

Antes de que cualquier cliente o servicio no interactivo llame a tu API, debes definir los permisos o Scopes que permite tu API. Puedes configurar los alcances en Auth0 Dashboard para incluirlos en tu solicitud de autenticación a la Authentication API. Para ver más ejemplos de cómo usar los alcances de API, consulta [Alcances de API](/es/docs/get-started/apis/scopes/api-scopes).

Para configurar alcances, sigue las instrucciones de [Agregar permisos de API](/es/docs/get-started/apis/add-api-permissions) en Auth0 Dashboard o usa el ejemplo proporcionado para Management API.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Para agregar claims personalizadas a un token de acceso, puedes usar el flujo de Machine-to-Machine de Actions. Para obtener más información, consulta Machine to Machine Flow.
</Callout>

<div id="branding">
  ## Marca
</div>

Incluso si atiende a clientes o servicios no interactivos que funcionan en el canal secundario, aún puede personalizar la experiencia para que se ajuste a la imagen de su marca existente.

<div id="custom-domains">
  ### Dominios personalizados
</div>

Auth0 admite el uso de dominios personalizados cuando llamas al endpoint `/authorize` para solicitar tokens de acceso.

<Card title="Onboarding de M2M: dominios personalizados">
  En Auth0 Dashboard, debes:

  * Registrar y verificar tu dominio antes de poder usarlo con tus servicios de Auth0.
  * Decidir si quieres administrar tu propio certificado o usar un certificado administrado por Auth0. Para obtener más información sobre los certificados, consulta [Opciones de administración de certificados](/es/docs/customize/custom-domains#certificate-management-options).
  * Verificar que la versión de TLS (SSL) y la suite de cifrado que quieres usar para certificados autogestionados sean compatibles con Auth0. Para obtener más información, consulta [Versiones y suites de cifrado de TLS (SSL)](/es/docs/customize/custom-domains/self-managed-certificates/tls-ssl).
</Card>

1. Para configurar tu dominio personalizado con certificados administrados por Auth0, sigue las instrucciones de [Configurar dominios personalizados con certificados administrados por Auth0](/es/docs/customize/custom-domains/auth0-managed-certificates).

   1. Si quieres administrar tus propios certificados, sigue las instrucciones de [Configurar dominios personalizados con certificados autogestionados](/es/docs/customize/custom-domains/self-managed-certificates).

      <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
        Debes tener una suscripción Enterprise para administrar certificados en tu dominio personalizado. Para obtener más información, consulta [Precios de Auth0](https://auth0.com/pricing/) y [Inicio de sesión](/es/docs/authenticate/login).
      </Callout>
2. Revisa [Configuración de la API con dominios personalizados](/es/docs/customize/custom-domains/configure-features-to-use-custom-domains#apis). Es posible que debas ajustar la configuración de tu API para incorporar un dominio personalizado.

<div id="deployment-automation">
  ## Automatización de la implementación
</div>

Auth0 ofrece varias opciones para la automatización de la implementación, y puede usar cada una de ellas en conjunto con las demás.

<Card title="Práctica recomendada">
  Independientemente de cómo configure la automatización de la implementación, le recomendamos que ejecute pruebas unitarias en su código personalizado y en sus Actions antes de la implementación, y también algunas pruebas de integración en su inquilino después de la implementación.
</Card>

<div id="deploy-cli-tool">
  ### Herramienta Deploy CLI
</div>

Como se recomienda en la sección Arquitectura, debe contar con inquilinos de Auth0 para desarrollo, pruebas y producción. Estos inquilinos deben compartir configuraciones idénticas para los controles de calidad y las pruebas; sin embargo, puede encontrarse con errores como resultado de discrepancias de configuración entre sus entornos. Por ejemplo, cada entorno tendrá diferentes <Tooltip tip="ID de cliente: valor de identificación proporcionado por Auth0 a su recurso registrado." cta="Ver glosario" href="/es/docs/glossary?term=Client+IDs">ID de cliente</Tooltip> y <Tooltip tip="Secreto del cliente: cadena confidencial asignada a su recurso registrado por Auth0." cta="Ver glosario" href="/es/docs/glossary?term=Client+Secrets">Secretos del cliente</Tooltip>.

Para mitigar estos errores por discrepancias, puede usar la herramienta Deploy CLI para integrar su instancia de Auth0 con su pipeline de CI/CD existente.  Con el reemplazo dinámico de palabras clave, puede reemplazar variables de entorno en inquilinos que comparten configuraciones similares. Para obtener más información, consulte [Deploy CLI Tool](/es/docs/deploy-monitor/deploy-cli-tool) y [Keyword Replacement](/es/docs/deploy-monitor/deploy-cli-tool/keyword-replacement).

<div id="actions-real-time-logs">
  ### Actions Real-time Logs
</div>

Actions Real-time Logs muestra todos los registros del código personalizado en tiempo real, incluida la salida de `console.log` y otras excepciones. Si utiliza Auth0 Actions u otra lógica personalizada, puede usar esta extensión para depurar y solucionar problemas. Para obtener más información sobre la instalación y la configuración, consulte [Actions Real-time Logs](/es/docs/customize/actions/actions-real-time-logs).

<div id="quality-assurance">
  ## Garantía de calidad
</div>

La garantía de calidad es importante para identificar problemas antes de pasar a producción. Según la naturaleza de tu proyecto, hay varios tipos de pruebas de garantía de calidad que conviene considerar como parte de tu integración con Auth0:

* ¿Cómo responderán tus API cuando se las someta a cargas de producción inesperadas?
* ¿Cómo se verán afectados tus límites de tasa por las aplicaciones de terceros?

Si no utilizas widgets o funciones de Auth0, como <Tooltip tip="Universal Login: Tu aplicación redirige a Universal Login, alojado en el Servidor de autorización de Auth0, para verificar la identidad de un usuario." cta="Ver glosario" href="/es/docs/glossary?term=Universal+Login">Universal Login</Tooltip>, no contarás de forma predeterminada con prácticas recomendadas integradas de usabilidad y accesibilidad para una amplia variedad de navegadores y dispositivos. Para garantizar que se cumplan los requisitos funcionales y que los eventos inesperados se gestionen correctamente, se ofrece orientación para probar la integración entre tus aplicaciones y Auth0, y para realizar pruebas unitarias de módulos de extensibilidad individuales, como Auth0 Actions. También te recomendamos revisar la [política de pruebas de penetración](/es/docs/troubleshoot/customer-support/operational-policies/penetration-testing-policy) de Auth0 y realizar pruebas Mock que puedas aprovechar junto con nuestra [política de pruebas de carga](/es/docs/troubleshoot/customer-support/operational-policies/load-testing-policy) para ayudar a garantizar que tus aplicaciones funcionen correctamente ante cargas inesperadas.

<div id="unit-testing">
  ### Pruebas unitarias
</div>

Las pruebas unitarias consisten en verificar unidades de extensibilidad, como Auth0 Actions. Si utiliza código personalizado, le recomendamos usar un framework de pruebas (como [Mocha](https://mochajs.org/)) para probar ese código adicional antes de la implementación.

<div id="mock-testing">
  ### Pruebas Mock
</div>

Para equilibrar la [política de pruebas de carga](/es/docs/troubleshoot/customer-support/operational-policies/load-testing-policy) de Auth0 con la necesidad de realizar pruebas de carga, es habitual crear una prueba Mock de los endpoints de Auth0. Esta práctica es valiosa para garantizar que su configuración funcione con las interfaces previstas sin tener que limitar sus pruebas, y puede apoyarse en herramientas como [MockServer](http://www.mock-server.com/), [JSON Server](https://github.com/typicode/json-server) o incluso [Postman](https://learning.getpostman.com/docs/postman/mock_servers/setting_up_mock/).

<div id="deployment">
  ## Implementación
</div>

Nuestra sección [Implementar y supervisar](/es/docs/deploy-monitor) ofrece orientación sobre las prácticas recomendadas de implementación. Le recomendamos revisar las [Comprobaciones previas a la implementac](/es/docs/deploy-monitor/pre-deployment-checks)[ión](/es/docs/deploy-monitor/pre-deployment-checks), especialmente las [Comprobaciones de preparación de Auth0 Dashboard](/es/docs/deploy-monitor/pre-deployment-checks/how-to-run-production-checks) integradas.

Para revisar la comprobación de preparación, seleccione el menú desplegable situado debajo del nombre de su inquilino y la etiqueta del entorno en [Auth0 Dashboard > Ejecutar comprobaciones de preparación](https://manage.auth0.com/#/production-checks).

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=818c1928dd347f6f8231793e30a70041" alt="Auth0 Dashboard > Lista de verificación de preparación" data-og-width="1002" width="1002" data-og-height="730" height="730" data-path="docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=280&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=4f01becf68d0b11aa53991ee3058ae29 280w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=560&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=58060672e08a237b4e58cc78d17f6ed7 560w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=840&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=83bfdd6c132c0f0308582e51191602f0 840w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=1100&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=3bd522d521dd84dc26e58f9b294c5e3e 1100w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=1650&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=09c2f9d8d19fdd2799daa6ae67b3c8a8 1650w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=2500&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=78272d1d6b0337a489eefb36719a0825 2500w" />
</Frame>

Puede usar el filtro para aplicar las comprobaciones de preparación a las aplicaciones seleccionadas. **Estas comprobaciones no se aplican a las API que haya configurado**.

Para las comprobaciones que no se apliquen a su configuración específica, puede seleccionar **Descartar** para quitarlas de los resultados finales.

Le recomendamos revisar las [Prácticas recomendadas de implementación](/es/docs/deploy-monitor/deployment-best-practices) para realizar las comprobaciones finales antes de entrar en producción y aprovechar los [Registros](/es/docs/deploy-monitor/logs) para supervisar sus servicios.

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

* [Descripción general de Auth0](/es/docs/get-started/auth0-overview)
* [Descripción general de la solución (aplicaciones de servidor + API)](/es/docs/get-started/architecture-scenarios/server-application-api/part-1)
* [Llame a su API con el flujo de credenciales del cliente](/es/docs/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow)
* [Recupere eventos de registro mediante la Management API](/es/docs/deploy-monitor/logs/retrieve-log-events-using-mgmt-api)
* [Obtenga tokens de acceso de la Management API para producción](/es/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production)